You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
610 lines
23 KiB
610 lines
23 KiB
var $ = require('jquery');
|
|
var EthJSVM = require('ethereumjs-vm');
|
|
var Trie = require('merkle-patricia-tree');
|
|
var ethJSUtil = require('ethereumjs-util');
|
|
var EthJSTX = require('ethereumjs-tx');
|
|
var ethJSABI = require('ethereumjs-abi');
|
|
var EthJSBlock = require('ethereumjs-block');
|
|
var web3 = require('./web3-adapter.js');
|
|
|
|
function UniversalDApp (contracts, options) {
|
|
this.options = options || {};
|
|
this.$el = $('<div class="udapp" />');
|
|
this.contracts = contracts;
|
|
this.renderOutputModifier = options.renderOutputModifier || function(name, content) { return content; };
|
|
|
|
if (options.vm) {
|
|
this.accounts = {};
|
|
|
|
this.BN = ethJSUtil.BN;
|
|
this.stateTrie = new Trie();
|
|
this.vm = new EthJSVM(this.stateTrie, null, { activatePrecompiles: true });
|
|
|
|
this.addAccount('3cd7232cd6f3fc66a57a6bedc1a8ed6c228fff0a327e169c2bcc5e869ed49511');
|
|
this.addAccount('2ac6c190b09897cd8987869cc7b918cfea07ee82038d492abce033c75c1b1d0c');
|
|
} else if (!web3.currentProvider) {
|
|
var host = options.host || "localhost";
|
|
var port = options.port || "8545";
|
|
var rpc_url = options.getWeb3endpoint ? options.getWeb3endpoint() : ('http://' + host + ':' + port);
|
|
web3.setProvider( new web3.providers.HttpProvider( rpc_url ) );
|
|
}
|
|
|
|
}
|
|
|
|
UniversalDApp.prototype.addAccount = function (privateKey, balance) {
|
|
if (this.accounts) {
|
|
privateKey = new Buffer(privateKey, 'hex');
|
|
var address = ethJSUtil.privateToAddress(privateKey);
|
|
|
|
// FIXME: we don't care about the callback, but we should still make this proper
|
|
this.vm.stateManager.putAccountBalance(address, balance || 'f00000000000000001', function cb() {} );
|
|
|
|
this.accounts['0x' + address.toString('hex')] = { privateKey: privateKey, nonce: 0 };
|
|
}
|
|
};
|
|
|
|
UniversalDApp.prototype.getAccounts = function (cb) {
|
|
if (!this.vm) {
|
|
web3.eth.getAccounts(cb);
|
|
} else {
|
|
if (!this.accounts) return cb("No accounts?");
|
|
|
|
cb(null, Object.keys(this.accounts));
|
|
}
|
|
};
|
|
|
|
UniversalDApp.prototype.getBalance = function (address, cb) {
|
|
address = ethJSUtil.stripHexPrefix(address);
|
|
|
|
if (!this.vm) {
|
|
web3.eth.getBalance(address, function (err, res) {
|
|
if (err) {
|
|
cb(err);
|
|
} else {
|
|
cb(null, res.toString(10));
|
|
}
|
|
});
|
|
} else {
|
|
if (!this.accounts) return cb("No accounts?");
|
|
|
|
this.vm.stateManager.getAccountBalance(new Buffer(address, 'hex'), function (err, res) {
|
|
if (err) {
|
|
cb("Account not found");
|
|
} else {
|
|
cb(null, new ethJSUtil.BN(res).toString(10));
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
UniversalDApp.prototype.render = function () {
|
|
if (this.contracts.length == 0) {
|
|
this.$el.append( this.getABIInputForm() );
|
|
} else {
|
|
|
|
for (var c in this.contracts) {
|
|
var $contractEl = $('<div class="contract"/>');
|
|
|
|
if (this.contracts[c].address) {
|
|
this.getInstanceInterface(this.contracts[c], this.contracts[c].address, $contractEl );
|
|
} else {
|
|
var $title = $('<span class="title"/>').text( this.contracts[c].name );
|
|
if (this.contracts[c].bytecode) {
|
|
$title.append($('<div class="size"/>').text((this.contracts[c].bytecode.length / 2) + ' bytes'));
|
|
}
|
|
$contractEl.append( $title ).append( this.getCreateInterface( $contractEl, this.contracts[c]) );
|
|
}
|
|
this.$el.append(this.renderOutputModifier(this.contracts[c].name, $contractEl));
|
|
}
|
|
}
|
|
$legend = $('<div class="legend" />')
|
|
.append( $('<div class="attach"/>').text('Attach') )
|
|
.append( $('<div class="transact"/>').text('Transact') )
|
|
.append( $('<div class="call"/>').text('Call') );
|
|
|
|
this.$el.append( $('<div class="poweredBy" />')
|
|
.html("<a href='http://github.com/d11e9/universal-dapp'>Universal ÐApp</a> powered by The Blockchain") );
|
|
|
|
this.$el.append( $legend );
|
|
return this.$el;
|
|
};
|
|
|
|
UniversalDApp.prototype.getContractByName = function(contractName) {
|
|
for (var c in this.contracts)
|
|
if (this.contracts[c].name == contractName)
|
|
return this.contracts[c];
|
|
return null;
|
|
};
|
|
|
|
UniversalDApp.prototype.getABIInputForm = function (cb){
|
|
var self = this;
|
|
var $el = $('<div class="udapp-setup" />');
|
|
var $jsonInput = $('<textarea class="json" placeholder=\'[ { "name": name, "bytecode": bytecode, "interface": abi }, { ... } ]\'/>');
|
|
var $createButton = $('<button class="udapp-create"/>').text('Create a Universal ÐApp');
|
|
$createButton.click(function(ev){
|
|
var contracts = $.parseJSON( $jsonInput.val() );
|
|
if (cb) {
|
|
var err = null;
|
|
var dapp = null;
|
|
try {
|
|
dapp = new UniversalDApp( contracts, self.options );
|
|
} catch(e) {
|
|
err = e;
|
|
}
|
|
cb( err, dapp );
|
|
} else {
|
|
self.contracts = contracts;
|
|
self.$el.empty().append( self.render() );
|
|
}
|
|
});
|
|
$el.append( $jsonInput ).append( $createButton );
|
|
return $el;
|
|
};
|
|
|
|
|
|
UniversalDApp.prototype.getCreateInterface = function ($container, contract) {
|
|
var self = this;
|
|
var $createInterface = $('<div class="create"/>');
|
|
if (this.options.removable) {
|
|
var $close = $('<div class="udapp-close" />');
|
|
$close.click( function(){ self.$el.remove(); } );
|
|
$createInterface.append( $close );
|
|
}
|
|
var $newButton = this.getInstanceInterface( contract );
|
|
var $atButton = $('<button class="atAddress"/>').text('At Address').click( function(){ self.clickContractAt( self, $container.find('.createContract'), contract ); } );
|
|
$createInterface.append( $atButton ).append( $newButton );
|
|
return $createInterface;
|
|
};
|
|
|
|
UniversalDApp.prototype.getInstanceInterface = function (contract, address, $target) {
|
|
var self = this;
|
|
var abi = JSON.parse(contract.interface).sort(function(a,b){
|
|
if (a.name > b.name) return -1;
|
|
else return 1;
|
|
}).sort(function(a,b){
|
|
if (a.constant == true) return -1;
|
|
else return 1;
|
|
});
|
|
var web3contract = web3.eth.contract(abi);
|
|
var funABI = this.getConstructorInterface(abi);
|
|
var $createInterface = $('<div class="createContract"/>');
|
|
|
|
var appendFunctions = function (address, $el){
|
|
|
|
var $instance = $('<div class="instance"/>');
|
|
if (self.options.removable_instances) {
|
|
var $close = $('<div class="udapp-close" />');
|
|
$close.click( function(){ $instance.remove(); } );
|
|
$instance.append( $close );
|
|
}
|
|
var context = self.options.vm ? 'memory' : 'blockchain';
|
|
var $title = $('<span class="title"/>').text( contract.name + " at " + (self.options.vm ? '0x' : '') + address.toString('hex') + ' (' + context + ')');
|
|
$title.click(function(){
|
|
$instance.toggleClass('hide');
|
|
});
|
|
|
|
$events = $('<div class="events"/>');
|
|
|
|
var parseLogs = function(err,response) {
|
|
if (err)
|
|
return;
|
|
|
|
$event = $('<div class="event" />');
|
|
var $close = $('<div class="udapp-close" />');
|
|
$close.click( function(){ $event.remove(); } );
|
|
|
|
$event.append( $('<span class="name"/>').text(response.event) )
|
|
.append( $('<span class="args" />').text( JSON.stringify(response.args, null, 2) ) )
|
|
.append( $close );
|
|
|
|
$events.append( $event );
|
|
};
|
|
|
|
if (self.options.vm){
|
|
// FIXME: support indexed events
|
|
var eventABI = {};
|
|
|
|
$.each(abi, function(i, funABI) {
|
|
if (funABI.type !== 'event') return;
|
|
|
|
var hash = ethJSABI.eventID(funABI.name, funABI.inputs.map(function(item) { return item.type; }));
|
|
eventABI[hash.toString('hex')] = { event: funABI.name, inputs: funABI.inputs };
|
|
});
|
|
|
|
self.vm.on('afterTx', function(response){
|
|
for (var i in response.vm.logs) {
|
|
// [address, topics, mem]
|
|
var log = response.vm.logs[i];
|
|
var abi = eventABI[log[1][0].toString('hex')];
|
|
var event = abi.event;
|
|
var decoded;
|
|
|
|
try {
|
|
var types = abi.inputs.map(function (item) {
|
|
return item.type;
|
|
});
|
|
decoded = ethJSABI.rawDecode(types, log[2]);
|
|
decoded = ethJSABI.stringify(types, decoded);
|
|
} catch (e) {
|
|
decoded = '0x' + log[2].toString('hex');
|
|
}
|
|
|
|
parseLogs(null, { event: event, args: decoded });
|
|
}
|
|
});
|
|
} else {
|
|
var eventFilter = web3contract.at(address).allEvents();
|
|
eventFilter.watch(parseLogs);
|
|
}
|
|
$instance.append( $title );
|
|
|
|
// Add the fallback function
|
|
$instance.append(self.getCallButton({
|
|
abi: { constant: false, inputs:[], name: '(fallback)', outputs: [], type: 'function' },
|
|
encode: function(args) {
|
|
return '';
|
|
},
|
|
address: address
|
|
}));
|
|
|
|
$.each(abi, function(i, funABI) {
|
|
if (funABI.type != 'function') return;
|
|
// @todo getData cannot be used with overloaded functions
|
|
$instance.append(self.getCallButton({
|
|
abi: funABI,
|
|
encode: function(args) {
|
|
var obj = web3contract.at('0x00')[funABI.name];
|
|
return obj.getData.apply(obj, args);
|
|
},
|
|
address: address
|
|
}));
|
|
});
|
|
($el || $createInterface ).append( $instance.append( $events ) );
|
|
};
|
|
|
|
if (!address || !$target) {
|
|
$createInterface.append( this.getCallButton({
|
|
abi: funABI,
|
|
encode: function(args) {
|
|
var obj = web3contract.new;
|
|
return obj.getData.apply(obj, args);
|
|
},
|
|
contractName: contract.name,
|
|
bytecode: contract.bytecode,
|
|
appendFunctions: appendFunctions
|
|
}));
|
|
} else {
|
|
appendFunctions( address, $target );
|
|
}
|
|
|
|
return $createInterface;
|
|
};
|
|
|
|
UniversalDApp.prototype.getConstructorInterface = function(abi) {
|
|
var funABI = {'name':'','inputs':[],'type':'constructor','outputs':[]};
|
|
for (var i = 0; i < abi.length; i++)
|
|
if (abi[i].type == 'constructor') {
|
|
funABI.inputs = abi[i].inputs || [];
|
|
break;
|
|
}
|
|
return funABI;
|
|
};
|
|
|
|
UniversalDApp.prototype.getCallButton = function(args) {
|
|
var self = this;
|
|
// args.abi, args.encode, args.bytecode [constr only], args.address [fun only]
|
|
// args.contractName [constr only], args.appendFunctions [constr only]
|
|
var isConstructor = args.bytecode !== undefined;
|
|
var lookupOnly = ( args.abi.constant && !isConstructor );
|
|
|
|
var inputs = '';
|
|
$.each(args.abi.inputs, function(i, inp) {
|
|
if (inputs != '') inputs += ', ';
|
|
inputs += inp.type + ' ' + inp.name;
|
|
});
|
|
var inputField = $('<input/>').attr('placeholder', inputs).attr('title', inputs);
|
|
var $outputOverride = $('<div class="value" />');
|
|
var outputSpan = $('<div class="output"/>');
|
|
|
|
var getReturnOutput = function(result) {
|
|
var returnName = lookupOnly ? 'Value' : 'Result';
|
|
var returnCls = lookupOnly ? 'value' : 'returned';
|
|
return $('<div class="' + returnCls + '">').html('<strong>' + returnName + ':</strong> ' + JSON.stringify( result, null, 2 ) );
|
|
};
|
|
|
|
var getGasUsedOutput = function (result) {
|
|
var $gasUsed = $('<div class="gasUsed">');
|
|
var caveat = lookupOnly ? '<em>(<span class="caveat" title="Cost only applies when called by a contract">caveat</span>)</em>' : '';
|
|
if (result.gasUsed) {
|
|
var gas = result.gasUsed.toString(10);
|
|
$gasUsed.html('<strong>Cost:</strong> ' + gas + ' gas. ' + caveat );
|
|
}
|
|
return $gasUsed;
|
|
};
|
|
|
|
var getDecodedOutput = function (result) {
|
|
var $decoded;
|
|
if (Array.isArray(result)) {
|
|
$decoded = $('<ol>');
|
|
for (var i = 0; i < result.length; i++) {
|
|
$decoded.append($('<li>').text(result[i]));
|
|
}
|
|
} else {
|
|
$decoded = result;
|
|
}
|
|
return $('<div class="decoded">').html('<strong>Decoded:</strong> ').append($decoded);
|
|
};
|
|
|
|
var getOutput = function() {
|
|
var $result = $('<div class="result" />');
|
|
var $close = $('<div class="udapp-close" />');
|
|
$close.click( function(){ $result.remove(); } );
|
|
$result.append( $close );
|
|
return $result;
|
|
};
|
|
var clearOutput = function($result) {
|
|
$(':not(.udapp-close)', $result).remove();
|
|
};
|
|
var replaceOutput = function($result, message) {
|
|
clearOutput($result);
|
|
$result.append(message);
|
|
};
|
|
|
|
var handleCallButtonClick = function(ev, $result) {
|
|
if (!$result) {
|
|
$result = getOutput();
|
|
if (lookupOnly && !inputs.length)
|
|
$outputOverride.empty().append( $result );
|
|
else
|
|
outputSpan.append( $result );
|
|
}
|
|
|
|
var funArgs = '';
|
|
try {
|
|
funArgs = $.parseJSON('[' + inputField.val() + ']');
|
|
} catch (e) {
|
|
replaceOutput($result, $('<span/>').text('Error encoding arguments: ' + e));
|
|
return;
|
|
}
|
|
var data = '';
|
|
if (!isConstructor || funArgs.length > 0) {
|
|
try {
|
|
data = args.encode(funArgs);
|
|
} catch(e) {
|
|
replaceOutput($result, $('<span/>').text('Error encoding arguments: ' + e));
|
|
return;
|
|
}
|
|
}
|
|
if (data.slice(0, 9) == 'undefined')
|
|
data = data.slice(9);
|
|
if (data.slice(0, 2) == '0x') data = data.slice(2);
|
|
|
|
replaceOutput($result, $('<span>Waiting for transaction to be mined...</span>'));
|
|
|
|
if (isConstructor) {
|
|
if (args.bytecode.indexOf('_') >= 0) {
|
|
replaceOutput($result, $('<span>Deploying and linking required libraries...</span>'));
|
|
if (self.options.vm)
|
|
self.linkBytecode(args.contractName, function(err, bytecode) {
|
|
if (err)
|
|
replaceOutput($result, $('<span/>').text('Error deploying required libraries: ' + err));
|
|
else {
|
|
args.bytecode = bytecode;
|
|
handleCallButtonClick(ev, $result);
|
|
}
|
|
});
|
|
else
|
|
replaceOutput($result, $('<span>Contract needs to be linked to a library, this is only supported in the JavaScript VM for now.</span>'));
|
|
return;
|
|
} else
|
|
data = args.bytecode + data;
|
|
}
|
|
|
|
self.runTx(data, args, function(err, result) {
|
|
if (err) {
|
|
replaceOutput($result, $('<span/>').text(err).addClass('error'));
|
|
} else if (self.options.vm && result.vm.exception && result.vm.exceptionError) {
|
|
replaceOutput($result, $('<span/>').text('VM Exception: ' + result.vm.exceptionError).addClass('error'));
|
|
} else if (self.options.vm && result.vm.return === undefined) {
|
|
replaceOutput($result, $('<span/>').text('Exception during execution.').addClass('error'));
|
|
} else if (self.options.vm && isConstructor) {
|
|
replaceOutput($result, getGasUsedOutput(result));
|
|
args.appendFunctions(result.createdAddress);
|
|
} else if (self.options.vm){
|
|
var outputObj = '0x' + result.vm.return.toString('hex');
|
|
clearOutput($result);
|
|
$result.append(getReturnOutput(outputObj)).append(getGasUsedOutput(result.vm));
|
|
|
|
// Only decode if there supposed to be fields
|
|
if (args.abi.outputs.length > 0) {
|
|
try {
|
|
var outputTypes = [];
|
|
for (var i = 0; i < args.abi.outputs.length; i++) {
|
|
outputTypes.push(args.abi.outputs[i].type);
|
|
}
|
|
|
|
// decode data
|
|
var decodedObj = ethJSABI.rawDecode(outputTypes, result.vm.return);
|
|
|
|
// format decoded data
|
|
decodedObj = ethJSABI.stringify(outputTypes, decodedObj);
|
|
for (var i = 0; i < outputTypes.length; i++) {
|
|
var name = args.abi.outputs[i].name;
|
|
if (name.length > 0) {
|
|
decodedObj[i] = outputTypes[i] + ' ' + name + ': ' + decodedObj[i];
|
|
} else {
|
|
decodedObj[i] = outputTypes[i] + ': ' + decodedObj[i];
|
|
}
|
|
}
|
|
|
|
$result.append(getDecodedOutput(decodedObj));
|
|
} catch (e) {
|
|
$result.append(getDecodedOutput('Failed to decode output: ' + e));
|
|
}
|
|
}
|
|
} else if (args.abi.constant && !isConstructor) {
|
|
replaceOutput($result, getReturnOutput(result));
|
|
} else {
|
|
|
|
function tryTillResponse (txhash, done) {
|
|
web3.eth.getTransactionReceipt(result, testResult );
|
|
|
|
function testResult (err, address) {
|
|
if (!err && !address) {
|
|
setTimeout( function(){ tryTillResponse(txhash, done); }, 500);
|
|
} else done( err, address );
|
|
}
|
|
|
|
}
|
|
tryTillResponse( result, function(err, result) {
|
|
if (err) replaceOutput($result, $('<span/>').text(err).addClass('error'));
|
|
else if (isConstructor) {
|
|
$result.html('');
|
|
args.appendFunctions(result.contractAddress);
|
|
} else {
|
|
clearOutput($result);
|
|
$result.append(getReturnOutput(result)).append(getGasUsedOutput(result));
|
|
}
|
|
});
|
|
|
|
}
|
|
});
|
|
};
|
|
|
|
var button = $('<button />')
|
|
.addClass( 'call' )
|
|
.attr('title', args.abi.name)
|
|
.text(args.bytecode ? 'Create' : args.abi.name)
|
|
.click( handleCallButtonClick );
|
|
|
|
if (lookupOnly && !inputs.length) {
|
|
handleCallButtonClick();
|
|
}
|
|
|
|
var $contractProperty = $('<div class="contractProperty"/>');
|
|
$contractProperty
|
|
.toggleClass( 'constant', !isConstructor && args.abi.constant )
|
|
.toggleClass( 'hasArgs', args.abi.inputs.length > 0)
|
|
.toggleClass( 'constructor', isConstructor)
|
|
.append(button)
|
|
.append( (lookupOnly && !inputs.length) ? $outputOverride : inputField );
|
|
return $contractProperty.append(outputSpan);
|
|
};
|
|
|
|
UniversalDApp.prototype.linkBytecode = function(contractName, cb) {
|
|
var bytecode = this.getContractByName(contractName).bytecode;
|
|
if (bytecode.indexOf('_') < 0)
|
|
return cb(null, bytecode);
|
|
var m = bytecode.match(/__([^_]{1,36})__/);
|
|
if (!m)
|
|
return cb("Invalid bytecode format.");
|
|
var libraryName = m[1];
|
|
if (!this.getContractByName(libraryName))
|
|
return cb("Library " + libraryName + " not found.");
|
|
var self = this;
|
|
this.deployLibrary(libraryName, function(err, address) {
|
|
if (err) return cb(err);
|
|
var libLabel = '__' + libraryName + Array(39 - libraryName.length).join('_');
|
|
var hexAddress = address.toString('hex');
|
|
if (hexAddress.slice(0, 2) == '0x') hexAddress = hexAddress.slice(2);
|
|
hexAddress = Array(40 - hexAddress.length + 1).join('0') + hexAddress;
|
|
while (bytecode.indexOf(libLabel) >= 0)
|
|
bytecode = bytecode.replace(libLabel, hexAddress);
|
|
self.getContractByName(contractName).bytecode = bytecode;
|
|
self.linkBytecode(contractName, cb);
|
|
});
|
|
};
|
|
|
|
UniversalDApp.prototype.deployLibrary = function(contractName, cb) {
|
|
if (this.getContractByName(contractName).address)
|
|
return cb(null, this.getContractByName(contractName).address);
|
|
var self = this;
|
|
var bytecode = this.getContractByName(contractName).bytecode;
|
|
if (bytecode.indexOf('_') >= 0)
|
|
this.linkBytecode(contractName, function(err, bytecode) {
|
|
if (err) cb(err);
|
|
else self.deployLibrary(contractName, cb);
|
|
});
|
|
else {
|
|
this.runTx(bytecode, {abi: {constant: false}, bytecode: bytecode}, function(err, result) {
|
|
if (err) return cb(err);
|
|
self.getContractByName(contractName).address = result.createdAddress;
|
|
cb(err, result.createdAddress);
|
|
});
|
|
}
|
|
};
|
|
|
|
UniversalDApp.prototype.clickNewContract = function ( self, $contract, contract ) {
|
|
$contract.append( self.getInstanceInterface(contract) );
|
|
};
|
|
|
|
UniversalDApp.prototype.clickContractAt = function ( self, $output, contract ) {
|
|
var address = prompt( "What Address is this contract at in the Blockchain? ie: '0xdeadbeaf...'" );
|
|
self.getInstanceInterface(contract, address, $output );
|
|
};
|
|
|
|
UniversalDApp.prototype.runTx = function( data, args, cb) {
|
|
var self = this;
|
|
var to = args.address;
|
|
var constant = args.abi.constant;
|
|
var isConstructor = args.bytecode !== undefined;
|
|
if (data.slice(0, 2) != '0x')
|
|
data = '0x' + data;
|
|
|
|
var gas = self.options.getGas ? self.options.getGas : 1000000;
|
|
|
|
var value = 0;
|
|
if (self.options.getValue) {
|
|
try {
|
|
value = self.options.getValue();
|
|
} catch (e) {
|
|
return cb(e);
|
|
}
|
|
}
|
|
|
|
if (!this.vm) {
|
|
var tx = {
|
|
from: self.options.getAddress ? self.options.getAddress() : web3.eth.accounts[0],
|
|
to: to,
|
|
data: data,
|
|
gas: gas,
|
|
value: value
|
|
};
|
|
if (constant && !isConstructor) {
|
|
web3.eth.call( tx, cb );
|
|
} else {
|
|
web3.eth.estimateGas( tx, function(err, resp){
|
|
tx.gas = resp;
|
|
if (!err) web3.eth.sendTransaction( tx, cb );
|
|
else cb( err, resp);
|
|
});
|
|
}
|
|
} else {
|
|
try {
|
|
var address = this.options.getAddress ? this.options.getAddress() : this.getAccounts()[0];
|
|
var account = this.accounts[address];
|
|
var tx = new EthJSTX({
|
|
nonce: new Buffer([account.nonce++]), //@todo count beyond 255
|
|
gasPrice: 1,
|
|
gasLimit: 3000000000, //plenty
|
|
to: to,
|
|
value: new this.BN(value, 10),
|
|
data: new Buffer(data.slice(2), 'hex')
|
|
});
|
|
tx.sign(account.privateKey);
|
|
var block = new EthJSBlock({
|
|
header: {
|
|
// FIXME: support coinbase, difficulty, number and gasLimit
|
|
timestamp: new Date().getTime() / 1000 | 0
|
|
},
|
|
transactions: [],
|
|
uncleHeaders: []
|
|
});
|
|
this.vm.runTx({block: block, tx: tx, skipBalance: true, skipNonce: true, enableHomestead: true}, cb);
|
|
} catch (e) {
|
|
cb( e, null );
|
|
}
|
|
}
|
|
};
|
|
|
|
module.exports = UniversalDApp;
|
|
|