Files: cd54c9d2a59c3fbfe2477fd39f5493ec90eebb6b / index.js
7908 bytesRaw
1 | /** |
2 | * This implements the Ethereum Kernel |
3 | * Kernels must implement two methods `codeHandler` and `callHandler` (and `linkHandler` for sharding) |
4 | * The Kernel Contract handles the following |
5 | * - Interprocess communications |
6 | * - Intializing the VM and exposes ROM to it (codeHandler) |
7 | * - Expose namespace which VM instance exists and Intializes the Environment (callHandler) |
8 | * - Provides some built in contract (runTx, runBlock) |
9 | * - Provides resource sharing and limiting via gas |
10 | * |
11 | * All State should be stored in the Environment. |
12 | * |
13 | */ |
14 | |
15 | // The Kernel Exposes this Interface to VM instances it makes |
16 | const Interface = require('./interface.js') |
17 | |
18 | // The Kernel Stores all of its state in the Environment. The Interface is used |
19 | // to by the VM to retrive infromation from the Environment. |
20 | const Environment = require('./environment.js') |
21 | const DebugInterface = require('./debugInterface.js') |
22 | const Address = require('./address.js') |
23 | const U256 = require('./u256.js') |
24 | const Utils = require('./utils.js') |
25 | const Transaction = require('./transaction.js') |
26 | const Precompile = require('./precompile.js') |
27 | |
28 | const identityContract = new Address('0x0000000000000000000000000000000000000004') |
29 | const meteringContract = new Address('0x000000000000000000000000000000000000000A') |
30 | const transcompilerContract = new Address('0x000000000000000000000000000000000000000B') |
31 | |
32 | module.exports = class Kernel { |
33 | // runs some code in the VM |
34 | constructor (environment = new Environment()) { |
35 | this.environment = environment |
36 | } |
37 | |
38 | // handles running code. |
39 | // NOTE: it assumes that wasm will raise an exception if something went wrong, |
40 | // otherwise execution succeeded |
41 | codeHandler (code, ethInterface = new Interface(new Environment())) { |
42 | const debugInterface = new DebugInterface(ethInterface.environment) |
43 | |
44 | const instance = Wasm.instantiateModule(code, { |
45 | 'ethereum': ethInterface.exportTable, |
46 | 'debug': debugInterface.exportTable, |
47 | |
48 | // export this for Rust |
49 | // FIXME: remove once Rust has proper imports, see https://github.com/ethereum/evm2.0-design/issues/15 |
50 | 'spectest': ethInterface.exportTable, |
51 | |
52 | // export this for Binaryen |
53 | // FIXME: remove once C has proper imports, see https://github.com/ethereum/evm2.0-design/issues/16 |
54 | 'env': ethInterface.exportTable |
55 | }) |
56 | |
57 | ethInterface.setModule(instance) |
58 | debugInterface.setModule(instance) |
59 | |
60 | if (instance.exports.main) { |
61 | instance.exports.main() |
62 | } |
63 | return instance |
64 | } |
65 | |
66 | // loads code from the merkle trie and delegates the message |
67 | // Detects if code is EVM or WASM |
68 | // Detects if the code injection is needed |
69 | // Detects if transcompilation is needed |
70 | callHandler (call) { |
71 | // FIXME: this is here until these two contracts are compiled to WASM |
72 | // The two special contracts (precompiles now, but will be real ones later) |
73 | if (call.to.equals(meteringContract)) { |
74 | return Precompile.meteringInjector(call) |
75 | } else if (call.to.equals(transcompilerContract)) { |
76 | return Precompile.transcompiler(call) |
77 | } else if (call.to.equals(identityContract)) { |
78 | return Precompile.identity(call) |
79 | } |
80 | |
81 | let account = this.environment.state.get(call.to.toString()) |
82 | if (!account) { |
83 | throw new Error('Account not found: ' + call.to.toString()) |
84 | } |
85 | |
86 | let code = Uint8Array.from(account.get('code')) |
87 | if (code.length === 0) { |
88 | throw new Error('Contract not found') |
89 | } |
90 | |
91 | if (!Utils.isWASMCode(code)) { |
92 | // throw new Error('Not an eWASM contract') |
93 | |
94 | // Transcompile code |
95 | // FIXME: decide if these are the right values here: from: 0, gasLimit: 0, value: 0 |
96 | code = this.callHandler({ from: Address.zero(), to: transcompilerContract, gasLimit: 0, value: new U256(0), data: code }).returnValue |
97 | } |
98 | |
99 | // creats a new Kernel |
100 | const environment = new Environment() |
101 | environment.parent = this |
102 | |
103 | // copy the transaction details |
104 | environment.code = code |
105 | environment.address = call.to |
106 | // FIXME: make distinction between origin and caller |
107 | environment.origin = call.from |
108 | environment.caller = call.from |
109 | environment.callData = call.data |
110 | environment.callValue = call.value |
111 | environment.gasLeft = call.gasLimit |
112 | |
113 | environment.callHandler = this.callHandler.bind(this) |
114 | environment.createHandler = this.createHandler.bind(this) |
115 | |
116 | const kernel = new Kernel(this, environment) |
117 | kernel.codeHandler(code, new Interface(environment)) |
118 | |
119 | // generate new stateroot |
120 | // this.environment.state.set(address, { stateRoot: stateRoot }) |
121 | |
122 | return { |
123 | executionOutcome: 1, // success |
124 | gasLeft: new U256(environment.gasLeft), |
125 | gasRefund: new U256(environment.gasRefund), |
126 | returnValue: environment.returnValue, |
127 | selfDestructAddress: environment.selfDestructAddress, |
128 | logs: environment.logs |
129 | } |
130 | } |
131 | |
132 | createHandler (create) { |
133 | let code = create.data |
134 | |
135 | // Inject metering |
136 | if (Utils.isWASMCode(code)) { |
137 | // FIXME: decide if these are the right values here: from: 0, gasLimit: 0, value: 0 |
138 | code = this.callHandler({ from: Address.zero(), to: meteringContract, gasLimit: 0, value: new U256(0), data: code }).returnValue |
139 | } |
140 | |
141 | let address = Utils.newAccountAddress(create.from, code) |
142 | |
143 | this.environment.addAccount(address.toString(), { |
144 | balance: create.value, |
145 | code: code |
146 | }) |
147 | |
148 | // Run code and take return value as contract code |
149 | // FIXME: decide if these are the right values here: value: 0, data: '' |
150 | code = this.callHandler({ from: create.from, to: address, gasLimit: create.gasLimit, value: new U256(0), data: new Uint8Array() }).returnValue |
151 | |
152 | this.environment.state.get(address.toString()).set('code', code) |
153 | |
154 | return { |
155 | accountCreated: address |
156 | } |
157 | } |
158 | |
159 | // run tx; the tx message handler |
160 | runTx (tx, environment = new Environment()) { |
161 | this.environment = environment |
162 | |
163 | if (Buffer.isBuffer(tx) || typeof tx === 'string') { |
164 | tx = new Transaction(tx) |
165 | if (!tx.valid) { |
166 | throw new Error('Invalid transaction signature') |
167 | } |
168 | } |
169 | |
170 | // look up sender |
171 | let fromAccount = this.environment.state.get(tx.from.toString()) |
172 | if (!fromAccount) { |
173 | throw new Error('Sender account not found: ' + tx.from.toString()) |
174 | } |
175 | |
176 | if (fromAccount.get('nonce').gt(tx.nonce)) { |
177 | throw new Error(`Invalid nonce: ${fromAccount.get('nonce')} > ${tx.nonce}`) |
178 | } |
179 | |
180 | fromAccount.set('nonce', fromAccount.get('nonce').add(new U256(1))) |
181 | |
182 | // Special case: contract deployment |
183 | if (tx.to.isZero()) { |
184 | if (tx.data.length !== 0) { |
185 | console.log('This is a contract deployment transaction') |
186 | |
187 | // FIXME: deduct fees |
188 | |
189 | return this.createHandler({ |
190 | from: tx.from, |
191 | gasLimit: tx.gasLimit, |
192 | value: tx.value, |
193 | data: tx.data |
194 | }) |
195 | } |
196 | } |
197 | |
198 | // deduct gasLimit * gasPrice from sender |
199 | if (fromAccount.get('balance').lt(tx.gasLimit.mul(tx.gasPrice))) { |
200 | throw new Error(`Insufficient account balance: ${fromAccount.get('balance').toString()} < ${tx.gasLimit.mul(tx.gasPrice).toString()}`) |
201 | } |
202 | |
203 | fromAccount.set('balance', fromAccount.get('balance').sub(tx.gasLimit.mul(tx.gasPrice))) |
204 | |
205 | let ret = this.callHandler({ |
206 | to: tx.to, |
207 | from: tx.from, |
208 | gasLimit: tx.gasLimit, |
209 | value: tx.value, |
210 | data: tx.data |
211 | }) |
212 | |
213 | // refund gas |
214 | if (ret.executionOutcome === 1) { |
215 | fromAccount.set('balance', fromAccount.get('balance').add(tx.gasPrice.mul(ret.gasLeft.add(ret.gasRefund)))) |
216 | } |
217 | |
218 | // save new state? |
219 | |
220 | return { |
221 | returnValue: ret.returnValue, |
222 | gasLeft: ret.gasLeft, |
223 | logs: ret.logs |
224 | } |
225 | } |
226 | |
227 | // run block; the block message handler |
228 | runBlock (block, environment = new Environment()) { |
229 | // verify block then run each tx |
230 | block.tx.forEach((tx) => { |
231 | this.runTx(tx, environment) |
232 | }) |
233 | } |
234 | |
235 | // run blockchain |
236 | // runBlockchain () {} |
237 | } |
238 |
Built with git-ssb-web