@@ -122,10 +122,15 @@ EVMHost::EVMHost(langutil::EVMVersion _evmVersion, evmc::VM& _vm):
122122 m_evmRevision = EVMC_BERLIN;
123123 else if (_evmVersion == langutil::EVMVersion::london ())
124124 m_evmRevision = EVMC_LONDON;
125+ // TODO: support EVMVersion::paris()
125126 else
126127 assertThrow (false , Exception, " Unsupported EVM version"
127128
128- tx_context.block_difficulty = evmc::uint256be{200000000 };
129+ if (m_evmRevision >= EVMC_PARIS)
130+ // This is the value from the merge block.
131+ tx_context.block_prev_randao = 0xa86c2e601b6c44eb4848f7d23d9df3113fbcac42041c49cbed5000cb4f118777_bytes32;
132+ else
133+ tx_context.block_prev_randao = evmc::uint256be{200000000 };
129134 tx_context.block_gas_limit = 20000000 ;
130135 tx_context.block_coinbase = 0x7878787878787878787878787878787878787878_address;
131136 tx_context.tx_gas_price = evmc::uint256be{3000000000 };
@@ -145,7 +150,6 @@ EVMHost::EVMHost(langutil::EVMVersion _evmVersion, evmc::VM& _vm):
145150void EVMHost::reset ()
146151{
147152 accounts.clear ();
148- m_currentAddress = {};
149153 // Clear self destruct records
150154 recorded_selfdestructs.clear ();
151155 // Clear call records
@@ -194,14 +198,14 @@ void EVMHost::transfer(evmc::MockedAccount& _sender, evmc::MockedAccount& _recip
194198 _recipient.balance = convertToEVMC (u256 (convertFromEVMC (_recipient.balance )) + _value);
195199}
196200
197- void EVMHost::selfdestruct (const evmc::address& _addr, const evmc::address& _beneficiary) noexcept
201+ bool EVMHost::selfdestruct (const evmc::address& _addr, const evmc::address& _beneficiary) noexcept
198202{
199203 // TODO actual selfdestruct is even more complicated.
200204
201205 transfer (accounts[_addr], accounts[_beneficiary], convertFromEVMC (accounts[_addr].balance ));
202206
203207 // Record self destructs. Clearing will be done in newTransactionFrame().
204- MockedHost::selfdestruct (_addr, _beneficiary);
208+ return MockedHost::selfdestruct (_addr, _beneficiary);
205209}
206210
207211void EVMHost::recordCalls (evmc_message const & _message) noexcept
@@ -212,34 +216,34 @@ void EVMHost::recordCalls(evmc_message const& _message) noexcept
212216
213217// NOTE: this is used for both internal and external calls.
214218// External calls are triggered from ExecutionFramework and contain only EVMC_CREATE or EVMC_CALL.
215- evmc::result EVMHost::call (evmc_message const & _message) noexcept
219+ evmc::Result EVMHost::call (evmc_message const & _message) noexcept
216220{
217221 recordCalls (_message);
218- if (_message.destination == 0x0000000000000000000000000000000000000001_address)
222+ if (_message.recipient == 0x0000000000000000000000000000000000000001_address)
219223 return precompileECRecover (_message);
220- else if (_message.destination == 0x0000000000000000000000000000000000000002_address)
224+ else if (_message.recipient == 0x0000000000000000000000000000000000000002_address)
221225 return precompileSha256 (_message);
222- else if (_message.destination == 0x0000000000000000000000000000000000000003_address)
226+ else if (_message.recipient == 0x0000000000000000000000000000000000000003_address)
223227 return precompileRipeMD160 (_message);
224- else if (_message.destination == 0x0000000000000000000000000000000000000004_address)
228+ else if (_message.recipient == 0x0000000000000000000000000000000000000004_address)
225229 return precompileIdentity (_message);
226- else if (_message.destination == 0x0000000000000000000000000000000000000005_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
230+ else if (_message.recipient == 0x0000000000000000000000000000000000000005_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
227231 return precompileModExp (_message);
228- else if (_message.destination == 0x0000000000000000000000000000000000000006_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
232+ else if (_message.recipient == 0x0000000000000000000000000000000000000006_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
229233 {
230234 if (m_evmVersion <= langutil::EVMVersion::istanbul ())
231235 return precompileALTBN128G1Add<EVMC_ISTANBUL>(_message);
232236 else
233237 return precompileALTBN128G1Add<EVMC_LONDON>(_message);
234238 }
235- else if (_message.destination == 0x0000000000000000000000000000000000000007_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
239+ else if (_message.recipient == 0x0000000000000000000000000000000000000007_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
236240 {
237241 if (m_evmVersion <= langutil::EVMVersion::istanbul ())
238242 return precompileALTBN128G1Mul<EVMC_ISTANBUL>(_message);
239243 else
240244 return precompileALTBN128G1Mul<EVMC_LONDON>(_message);
241245 }
242- else if (_message.destination == 0x0000000000000000000000000000000000000008_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
246+ else if (_message.recipient == 0x0000000000000000000000000000000000000008_address && m_evmVersion >= langutil::EVMVersion::byzantium ())
243247 {
244248 if (m_evmVersion <= langutil::EVMVersion::istanbul ())
245249 return precompileALTBN128PairingProduct<EVMC_ISTANBUL>(_message);
@@ -262,7 +266,7 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
262266 message.gas -= message.input_data [i] == 0 ? evmasm::GasCosts::txDataZeroGas : evmasm::GasCosts::txDataNonZeroGas (m_evmVersion);
263267 if (message.gas < 0 )
264268 {
265- evmc::result result ({}) ;
269+ evmc::Result result;
266270 result.status_code = EVMC_OUT_OF_GAS;
267271 accounts = stateBackup;
268272 return result;
@@ -299,8 +303,8 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
299303 encodedNonce
300304 ), h160::AlignRight);
301305
302- message.destination = convertToEVMC (createAddress);
303- assertThrow (accounts.count (message.destination ) == 0 , Exception, " Account cannot exist"
306+ message.recipient = convertToEVMC (createAddress);
307+ assertThrow (accounts.count (message.recipient ) == 0 , Exception, " Account cannot exist"
304308
305309 code = evmc::bytes (message.input_data , message.input_data + message.input_size );
306310 }
@@ -313,35 +317,30 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
313317 keccak256 (bytes (message.input_data , message.input_data + message.input_size )).asBytes ()
314318 ), h160::AlignRight);
315319
316- message.destination = convertToEVMC (createAddress);
317- if (accounts.count (message.destination ) && (
318- accounts[message.destination ].nonce > 0 ||
319- !accounts[message.destination ].code .empty ()
320+ message.recipient = convertToEVMC (createAddress);
321+ if (accounts.count (message.recipient ) && (
322+ accounts[message.recipient ].nonce > 0 ||
323+ !accounts[message.recipient ].code .empty ()
320324 ))
321325 {
322- evmc::result result ({}) ;
326+ evmc::Result result;
323327 result.status_code = EVMC_OUT_OF_GAS;
324328 accounts = stateBackup;
325329 return result;
326330 }
327331
328332 code = evmc::bytes (message.input_data , message.input_data + message.input_size );
329333 }
330- else if (message.kind == EVMC_DELEGATECALL || message.kind == EVMC_CALLCODE)
331- {
332- code = accounts[message.destination ].code ;
333- message.destination = m_currentAddress;
334- }
335334 else
336- code = accounts[message.destination ].code ;
335+ code = accounts[message.code_address ].code ;
337336
338- auto & destination = accounts[message.destination ];
337+ auto & destination = accounts[message.recipient ];
339338
340339 if (value != 0 && message.kind != EVMC_DELEGATECALL && message.kind != EVMC_CALLCODE)
341340 {
342341 if (value > convertFromEVMC (sender.balance ))
343342 {
344- evmc::result result ({}) ;
343+ evmc::Result result;
345344 result.status_code = EVMC_INSUFFICIENT_BALANCE;
346345 accounts = stateBackup;
347346 return result;
@@ -355,12 +354,9 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
355354 if (m_evmRevision >= EVMC_BERLIN)
356355 {
357356 access_account (message.sender );
358- access_account (message.destination );
357+ access_account (message.recipient );
359358 }
360- evmc::address currentAddress = m_currentAddress;
361- m_currentAddress = message.destination ;
362- evmc::result result = m_vm.execute (*this , m_evmRevision, message, code.data (), code.size ());
363- m_currentAddress = currentAddress;
359+ evmc::Result result = m_vm.execute (*this , m_evmRevision, message, code.data (), code.size ());
364360
365361 if (message.kind == EVMC_CREATE || message.kind == EVMC_CREATE2)
366362 {
@@ -373,7 +369,7 @@ evmc::result EVMHost::call(evmc_message const& _message) noexcept
373369 }
374370 else
375371 {
376- result.create_address = message.destination ;
372+ result.create_address = message.recipient ;
377373 destination.code = evmc::bytes (result.output_data , result.output_data + result.output_size );
378374 destination.codehash = convertToEVMC (keccak256 ({result.output_data , result.output_size }));
379375 }
@@ -416,7 +412,7 @@ evmc::bytes32 EVMHost::convertToEVMC(h256 const& _data)
416412 return d;
417413}
418414
419- evmc::result EVMHost::precompileECRecover (evmc_message const & _message) noexcept
415+ evmc::Result EVMHost::precompileECRecover (evmc_message const & _message) noexcept
420416{
421417 // NOTE this is a partial implementation for some inputs.
422418
@@ -449,20 +445,14 @@ evmc::result EVMHost::precompileECRecover(evmc_message const& _message) noexcept
449445 }
450446 }
451447 };
452- evmc::result result = precompileGeneric (_message, inputOutput);
448+ evmc::Result result = precompileGeneric (_message, inputOutput);
453449 // ECRecover will return success with empty response in case of failure
454450 if (result.status_code != EVMC_SUCCESS && result.status_code != EVMC_OUT_OF_GAS)
455- // return resultWithGas(_message.gas, gas_cost, {});
456- {
457- result.status_code = EVMC_SUCCESS;
458- result.gas_left = _message.gas - gas_cost;
459- result.output_data = {};
460- result.output_size = 0 ;
461- }
451+ return resultWithGas (_message.gas , gas_cost, {});
462452 return result;
463453}
464454
465- evmc::result EVMHost::precompileSha256 (evmc_message const & _message) noexcept
455+ evmc::Result EVMHost::precompileSha256 (evmc_message const & _message) noexcept
466456{
467457 // static data so that we do not need a release routine...
468458 bytes static hash;
@@ -477,7 +467,7 @@ evmc::result EVMHost::precompileSha256(evmc_message const& _message) noexcept
477467 return resultWithGas (_message.gas , gas_cost, hash);
478468}
479469
480- evmc::result EVMHost::precompileRipeMD160 (evmc_message const & _message) noexcept
470+ evmc::Result EVMHost::precompileRipeMD160 (evmc_message const & _message) noexcept
481471{
482472 // NOTE this is a partial implementation for some inputs.
483473
@@ -579,7 +569,7 @@ evmc::result EVMHost::precompileRipeMD160(evmc_message const& _message) noexcept
579569 return precompileGeneric (_message, inputOutput);
580570}
581571
582- evmc::result EVMHost::precompileIdentity (evmc_message const & _message) noexcept
572+ evmc::Result EVMHost::precompileIdentity (evmc_message const & _message) noexcept
583573{
584574 // static data so that we do not need a release routine...
585575 bytes static data;
@@ -591,14 +581,14 @@ evmc::result EVMHost::precompileIdentity(evmc_message const& _message) noexcept
591581 return resultWithGas (_message.gas , gas_cost, data);
592582}
593583
594- evmc::result EVMHost::precompileModExp (evmc_message const &) noexcept
584+ evmc::Result EVMHost::precompileModExp (evmc_message const &) noexcept
595585{
596586 // TODO implement
597587 return resultWithFailure ();
598588}
599589
600590template <evmc_revision Revision>
601- evmc::result EVMHost::precompileALTBN128G1Add (evmc_message const & _message) noexcept
591+ evmc::Result EVMHost::precompileALTBN128G1Add (evmc_message const & _message) noexcept
602592{
603593 // NOTE this is a partial implementation for some inputs.
604594
@@ -866,7 +856,7 @@ evmc::result EVMHost::precompileALTBN128G1Add(evmc_message const& _message) noex
866856}
867857
868858template <evmc_revision Revision>
869- evmc::result EVMHost::precompileALTBN128G1Mul (evmc_message const & _message) noexcept
859+ evmc::Result EVMHost::precompileALTBN128G1Mul (evmc_message const & _message) noexcept
870860{
871861 // NOTE this is a partial implementation for some inputs.
872862
@@ -956,7 +946,7 @@ evmc::result EVMHost::precompileALTBN128G1Mul(evmc_message const& _message) noex
956946}
957947
958948template <evmc_revision Revision>
959- evmc::result EVMHost::precompileALTBN128PairingProduct (evmc_message const & _message) noexcept
949+ evmc::Result EVMHost::precompileALTBN128PairingProduct (evmc_message const & _message) noexcept
960950{
961951 // Base + per pairing gas.
962952 constexpr auto calc_cost = [](unsigned points) -> int64_t {
@@ -1124,7 +1114,7 @@ evmc::result EVMHost::precompileALTBN128PairingProduct(evmc_message const& _mess
11241114 return precompileGeneric (_message, inputOutput);
11251115}
11261116
1127- evmc::result EVMHost::precompileGeneric (
1117+ evmc::Result EVMHost::precompileGeneric (
11281118 evmc_message const & _message,
11291119 map<bytes, EVMPrecompileOutput> const & _inOut) noexcept
11301120{
@@ -1138,20 +1128,20 @@ evmc::result EVMHost::precompileGeneric(
11381128 return resultWithFailure ();
11391129}
11401130
1141- evmc::result EVMHost::resultWithFailure () noexcept
1131+ evmc::Result EVMHost::resultWithFailure () noexcept
11421132{
1143- evmc::result result ({}) ;
1133+ evmc::Result result;
11441134 result.status_code = EVMC_FAILURE;
11451135 return result;
11461136}
11471137
1148- evmc::result EVMHost::resultWithGas (
1138+ evmc::Result EVMHost::resultWithGas (
11491139 int64_t gas_limit,
11501140 int64_t gas_required,
11511141 bytes const & _data
11521142) noexcept
11531143{
1154- evmc::result result ({}) ;
1144+ evmc::Result result;
11551145 if (gas_limit < gas_required)
11561146 {
11571147 result.status_code = EVMC_OUT_OF_GAS;
@@ -1162,7 +1152,7 @@ evmc::result EVMHost::resultWithGas(
11621152 result.status_code = EVMC_SUCCESS;
11631153 result.gas_left = gas_limit - gas_required;
11641154 }
1165- result.output_data = _data.data ();
1155+ result.output_data = _data.empty () ? nullptr : _data. data ();
11661156 result.output_size = _data.size ();
11671157 return result;
11681158}
@@ -1209,10 +1199,11 @@ void EVMHostPrinter::balance()
12091199void EVMHostPrinter::selfdestructRecords ()
12101200{
12111201 for (auto const & record: m_host.recorded_selfdestructs )
1212- m_stateStream << " SELFDESTRUCT"
1213- << " BENEFICIARY "
1214- << m_host.convertFromEVMC (record.beneficiary )
1215- << endl;
1202+ for (auto const & beneficiary: record.second )
1203+ m_stateStream << " SELFDESTRUCT"
1204+ << " BENEFICIARY "
1205+ << m_host.convertFromEVMC (beneficiary)
1206+ << endl;
12161207}
12171208
12181209void EVMHostPrinter::callRecords ()
0 commit comments