mirror
/
remix-project
mirror of https://github.com/ethereum/remix-project.git
2
0
Fork 0
Code Issues Releases Wiki Activity

Udapp as a class

Browse Source
pull/5370/head
Grandschtroumpf 5 years ago
parent 063adbc28b
commit 9ae676db46
1 changed files with 325 additions and 260 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 211
      remix-lib/src/universalDapp.js

211
remix-lib/src/universalDapp.js
Unescape View File

@ -1,35 +1,43 @@
var async = require('async')
var ethJSUtil = require('ethereumjs-util')
var BN = ethJSUtil.BN
var crypto = require('crypto')
const async = require('async')
const ethJSUtil = require('ethereumjs-util')
const { BN, privateToAddress, isValidPrivate, stripHexPrefix } = ethJSUtil
const crypto = require('crypto')
import { EventEmitter } from 'events';
var TxRunner = require('./execution/txRunner')
var txHelper = require('./execution/txHelper')
var EventManager = require('./eventManager')
var executionContext = require('./execution/execution-context')
const TxRunner = require('./execution/txRunner')
const txHelper = require('./execution/txHelper')
const EventManager = require('./eventManager')
const executionContext = require('./execution/execution-context')
function UniversalDApp (registry) {
module.exports = class UniversalDApp {
constructor (config) {
this.events = new EventEmitter()
this.event = new EventManager()
var self = this
self._deps = {
config: registry.get('config').api
}
self._txRunnerAPI = {
config: self._deps.config,
this.config = config
this.txRunner = new TxRunner({}, {
config: config,
detectNetwork: (cb) => {
executionContext.detectNetwork(cb)
},
personalMode: () => {
return self._deps.config.get('settings/personal-mode')
return executionContext.getProvider() === 'web3' ? this.config.get('settings/personal-mode') : false
}
}
self.txRunner = new TxRunner({}, self._txRunnerAPI)
self.accounts = {}
self.resetEnvironment()
})
this.accounts = {}
executionContext.event.register('contextChanged', this.resetEnvironment.bind(this))
}
UniversalDApp.prototype.resetEnvironment = function () {
// TODO : event should be triggered by Udapp instead of TxListener
/** Listen on New Transaction. (Cannot be done inside constructor because txlistener doesn't exist yet) */
startListening (txlistener) {
txlistener.event.register('newTransaction', (tx) => {
this.events.emit('newTransaction', tx)
})
}
resetEnvironment () {
this.accounts = {}
if (executionContext.isVM()) {
this._addAccount('3cd7232cd6f3fc66a57a6bedc1a8ed6c228fff0a327e169c2bcc5e869ed49511', '0x56BC75E2D63100000')
@ -47,7 +55,7 @@ UniversalDApp.prototype.resetEnvironment = function () {
executionContext.detectNetwork(cb)
},
personalMode: () => {
return this._deps.config.get('settings/personal-mode')
return executionContext.getProvider() === 'web3' ? this._deps.config.get('settings/personal-mode') : false
}
})
this.txRunner.event.register('transactionBroadcasted', (txhash) => {
@ -58,26 +66,34 @@ UniversalDApp.prototype.resetEnvironment = function () {
})
}
UniversalDApp.prototype.resetAPI = function (transactionContextAPI) {
resetAPI (transactionContextAPI) {
this.transactionContextAPI = transactionContextAPI
}
UniversalDApp.prototype.createVMAccount = function (privateKey, balance, cb) {
/**
* Create a VM Account
* @param {{privateKey: string, balance: string}} newAccount The new account to create
*/
createVMAccount (newAccount) {
const { privateKey, balance } = newAccount
if (executionContext.getProvider() !== 'vm') {
throw new Error('plugin API does not allow creating a new account through web3 connection. Only vm mode is allowed')
}
this._addAccount(privateKey, balance)
privateKey = Buffer.from(privateKey, 'hex')
cb(null, '0x' + ethJSUtil.privateToAddress(privateKey).toString('hex'))
const privKey = Buffer.from(privateKey, 'hex')
return '0x' + ethJSUtil.privateToAddress(privKey).toString('hex')
}
UniversalDApp.prototype.newAccount = function (password, passwordPromptCb, cb) {
newAccount (password, passwordPromptCb, cb) {
if (!executionContext.isVM()) {
if (!this._deps.config.get('settings/personal-mode')) {
if (!this.config.get('settings/personal-mode')) {
return cb('Not running in personal mode')
}
passwordPromptCb((passphrase) => {
executionContext.web3().personal.newAccount(passphrase, cb)
})
} else {
var privateKey
let privateKey
do {
privateKey = crypto.randomBytes(32)
} while (!ethJSUtil.isValidPrivate(privateKey))
@ -86,16 +102,15 @@ UniversalDApp.prototype.newAccount = function (password, passwordPromptCb, cb) {
}
}
UniversalDApp.prototype._addAccount = function (privateKey, balance) {
var self = this
/** Add an account to the list of account (only for Javascript VM) */
_addAccount (privateKey, balance) {
if (!executionContext.isVM()) {
throw new Error('_addAccount() cannot be called in non-VM mode')
}
if (self.accounts) {
if (this.accounts) {
privateKey = Buffer.from(privateKey, 'hex')
var address = ethJSUtil.privateToAddress(privateKey)
const address = ethJSUtil.privateToAddress(privateKey)
// FIXME: we don't care about the callback, but we should still make this proper
let stateManager = executionContext.vm().stateManager
@ -106,37 +121,59 @@ UniversalDApp.prototype._addAccount = function (privateKey, balance) {
if (error) console.log(error)
})
})
self.accounts['0x' + address.toString('hex')] = { privateKey: privateKey, nonce: 0 }
this.accounts['0x' + address.toString('hex')] = { privateKey, nonce: 0 }
}
}
UniversalDApp.prototype.getAccounts = function (cb) {
var self = this
if (!executionContext.isVM()) {
// Weirdness of web3: listAccounts() is sync, `getListAccounts()` is async
// See: https://github.com/ethereum/web3.js/issues/442
if (this._deps.config.get('settings/personal-mode')) {
return executionContext.web3().personal.getListAccounts(cb)
/** Return the list of accounts */
getAccounts (cb) {
return new Promise((resolve, reject) => {
const provider = executionContext.getProvider()
switch (provider) {
case 'vm': {
if (!this.accounts) {
if (cb) cb('No accounts?')
reject('No accounts?')
return
}
if (cb) cb(null, Object.keys(this.accounts))
resolve(Object.keys(this.accounts))
}
break
case 'web3': {
if (this.config.get('settings/personal-mode')) {
return executionContext.web3().personal.getListAccounts((error, accounts) => {
if (cb) cb(error, accounts)
if (error) return reject(error)
resolve(accounts)
})
} else {
executionContext.web3().eth.getAccounts(cb)
executionContext.web3().eth.getAccounts((error, accounts) => {
if (cb) cb(error, accounts)
if (error) return reject(error)
resolve(accounts)
})
}
} else {
if (!self.accounts) {
return cb('No accounts?')
}
cb(null, Object.keys(self.accounts))
break
case 'injected': {
executionContext.web3().eth.getAccounts((error, accounts) => {
if (cb) cb(error, accounts)
if (error) return reject(error)
resolve(accounts)
})
}
}
})
}
UniversalDApp.prototype.getBalance = function (address, cb) {
var self = this
/** Get the balance of an address */
getBalance (address, cb) {
address = ethJSUtil.stripHexPrefix(address)
if (!executionContext.isVM()) {
executionContext.web3().eth.getBalance(address, function (err, res) {
executionContext.web3().eth.getBalance(address, (err, res) => {
if (err) {
cb(err)
} else {
@ -144,11 +181,11 @@ UniversalDApp.prototype.getBalance = function (address, cb) {
}
})
} else {
if (!self.accounts) {
if (!this.accounts) {
return cb('No accounts?')
}
executionContext.vm().stateManager.getAccount(Buffer.from(address, 'hex'), function (err, res) {
executionContext.vm().stateManager.getAccount(Buffer.from(address, 'hex'), (err, res) => {
if (err) {
cb('Account not found')
} else {
@ -158,9 +195,9 @@ UniversalDApp.prototype.getBalance = function (address, cb) {
}
}
UniversalDApp.prototype.getBalanceInEther = function (address, callback) {
var self = this
self.getBalance(address, (error, balance) => {
/** Get the balance of an address, and convert wei to ether */
getBalanceInEther (address, callback) {
this.getBalance(address, (error, balance) => {
if (error) {
callback(error)
} else {
@ -169,7 +206,7 @@ UniversalDApp.prototype.getBalanceInEther = function (address, callback) {
})
}
UniversalDApp.prototype.pendingTransactionsCount = function () {
pendingTransactionsCount () {
return Object.keys(this.txRunner.pendingTxs).length
}
@ -179,7 +216,7 @@ UniversalDApp.prototype.pendingTransactionsCount = function () {
* @param {String} data - data to send with the transaction ( return of txFormat.buildData(...) ).
* @param {Function} callback - callback.
*/
UniversalDApp.prototype.createContract = function (data, confirmationCb, continueCb, promptCb, callback) {
createContract (data, confirmationCb, continueCb, promptCb, callback) {
this.runTx({data: data, useCall: false}, confirmationCb, continueCb, promptCb, (error, txResult) => {
// see universaldapp.js line 660 => 700 to check possible values of txResult (error case)
callback(error, txResult)
@ -194,32 +231,60 @@ UniversalDApp.prototype.createContract = function (data, confirmationCb, continu
* @param {Object} funAbi - abi definition of the function to call.
* @param {Function} callback - callback.
*/
UniversalDApp.prototype.callFunction = function (to, data, funAbi, confirmationCb, continueCb, promptCb, callback) {
callFunction (to, data, funAbi, confirmationCb, continueCb, promptCb, callback) {
this.runTx({to: to, data: data, useCall: funAbi.constant}, confirmationCb, continueCb, promptCb, (error, txResult) => {
// see universaldapp.js line 660 => 700 to check possible values of txResult (error case)
callback(error, txResult)
})
}
UniversalDApp.prototype.context = function () {
context () {
return (executionContext.isVM() ? 'memory' : 'blockchain')
}
UniversalDApp.prototype.getABI = function (contract) {
getABI (contract) {
return txHelper.sortAbiFunction(contract.abi)
}
UniversalDApp.prototype.getFallbackInterface = function (contractABI) {
getFallbackInterface (contractABI) {
return txHelper.getFallbackInterface(contractABI)
}
UniversalDApp.prototype.getInputs = function (funABI) {
getInputs (funABI) {
if (!funABI.inputs) {
return ''
}
return txHelper.inputParametersDeclarationToString(funABI.inputs)
}
/**
* This function send a tx only to javascript VM or testnet, will return an error for the mainnet
* SHOULD BE TAKEN CAREFULLY!
*
* @param {Object} tx - transaction.
*/
sendTransaction (tx) {
return new Promise((resolve, reject) => {
executionContext.detectNetwork((error, network) => {
if (error) return reject(error)
if (network.name === 'Main' && network.id === '1') {
return reject(new Error('It is not allowed to make this action against mainnet'))
}
this.silentRunTx(tx, (error, result) => {
if (error) return reject(error)
resolve({
transactionHash: result.transactionHash,
status: result.result.status,
gasUsed: '0x' + result.result.gasUsed.toString('hex'),
error: result.result.vm.exceptionError,
return: result.result.vm.return ? '0x' + result.result.vm.return.toString('hex') : '0x',
createdAddress: result.result.createdAddress ? '0x' + result.result.createdAddress.toString('hex') : undefined
})
})
})
})
}
/**
* This function send a tx without alerting the user (if mainnet or if gas estimation too high).
* SHOULD BE TAKEN CAREFULLY!
@ -227,17 +292,18 @@ UniversalDApp.prototype.getInputs = function (funABI) {
* @param {Object} tx - transaction.
* @param {Function} callback - callback.
*/
UniversalDApp.prototype.silentRunTx = function (tx, cb) {
silentRunTx (tx, cb) {
if (!executionContext.isVM()) return cb('Cannot silently send transaction through a web3 provider')
this.txRunner.rawRun(
tx,
(network, tx, gasEstimation, continueTxExecution, cancelCb) => { continueTxExecution() },
(error, continueTxExecution, cancelCb) => { if (error) { cb(error) } else { continueTxExecution() } },
(okCb, cancelCb) => { okCb() },
cb)
cb
)
}
UniversalDApp.prototype.runTx = function (args, confirmationCb, continueCb, promptCb, cb) {
runTx (args, confirmationCb, continueCb, promptCb, cb) {
const self = this
async.waterfall([
function getGasLimit (next) {
@ -278,9 +344,9 @@ UniversalDApp.prototype.runTx = function (args, confirmationCb, continueCb, prom
})
},
function runTransaction (fromAddress, value, gasLimit, next) {
var tx = { to: args.to, data: args.data.dataHex, useCall: args.useCall, from: fromAddress, value: value, gasLimit: gasLimit, timestamp: args.data.timestamp }
var payLoad = { funAbi: args.data.funAbi, funArgs: args.data.funArgs, contractBytecode: args.data.contractBytecode, contractName: args.data.contractName, contractABI: args.data.contractABI, linkReferences: args.data.linkReferences }
var timestamp = Date.now()
const tx = { to: args.to, data: args.data.dataHex, useCall: args.useCall, from: fromAddress, value: value, gasLimit: gasLimit, timestamp: args.data.timestamp }
const payLoad = { funAbi: args.data.funAbi, funArgs: args.data.funArgs, contractBytecode: args.data.contractBytecode, contractName: args.data.contractName, contractABI: args.data.contractABI, linkReferences: args.data.linkReferences }
const timestamp = Date.now()
if (tx.timestamp) {
timestamp = tx.timestamp
}
@ -303,5 +369,4 @@ UniversalDApp.prototype.runTx = function (args, confirmationCb, continueCb, prom
}
], cb)
}
module.exports = UniversalDApp
}
Write Preview
Loading…
Cancel
Save