From b0b4608450747033e8dac3d8d80796505f4f3621 Mon Sep 17 00:00:00 2001 From: HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com> Date: Sat, 1 Jun 2024 16:22:31 +0800 Subject: [PATCH] feat: config several forks opcodes & precompiles (#780) * add Curie & Descartes InstructionSet; update LondonInstructionSet * update core/vm/runtime/runtime.go * update core/vm/opcodes.go * update tests/init.go * update core/vm/contracts.go * update eth/tracers/js/tracer_test.go * update core/state_processor_test.go * london: update core/types/transaction_signing.go * update tests/init.go * update core/txpool/validation.go * update tests/state_test_util.go * remove selfdestruct --- core/state_processor_test.go | 3 ++ core/txpool/validation.go | 4 +- core/types/transaction_signing.go | 75 ++++++++++++++++++++++++++++++- core/vm/contracts.go | 57 ++++++++++++++++------- core/vm/eips.go | 16 ++++--- core/vm/evm.go | 6 ++- core/vm/gas_table.go | 3 ++ core/vm/interpreter.go | 4 ++ core/vm/jump_table.go | 33 ++++++++++---- core/vm/opcodes.go | 20 ++++++--- core/vm/operations_acl.go | 10 +++-- core/vm/runtime/runtime.go | 4 ++ eth/tracers/js/tracer_test.go | 42 +++++++++++++++++ tests/init.go | 35 +++++++++++++++ tests/state_test_util.go | 2 +- 15 files changed, 268 insertions(+), 46 deletions(-) diff --git a/core/state_processor_test.go b/core/state_processor_test.go index 5b314b7d21..c314c2a15e 100644 --- a/core/state_processor_test.go +++ b/core/state_processor_test.go @@ -64,6 +64,9 @@ func TestStateProcessorErrors(t *testing.T) { TerminalTotalDifficultyPassed: true, ShanghaiTime: new(uint64), CancunTime: new(uint64), + BernoulliBlock: big.NewInt(0), + CurieBlock: big.NewInt(0), + DescartesBlock: big.NewInt(0), } signer = types.LatestSigner(config) key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") diff --git a/core/txpool/validation.go b/core/txpool/validation.go index eeba1d8255..6770483fe8 100644 --- a/core/txpool/validation.go +++ b/core/txpool/validation.go @@ -59,10 +59,10 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types } // Ensure only transactions that have been enabled are accepted if !opts.Config.IsCurie(head.Number) && tx.Type() != types.LegacyTxType { - return fmt.Errorf("%w: type %d rejected, pool not yet in Berlin", core.ErrTxTypeNotSupported, tx.Type()) + return fmt.Errorf("%w: type %d rejected, pool not yet in Curie", core.ErrTxTypeNotSupported, tx.Type()) } if !opts.Config.IsCurie(head.Number) && tx.Type() == types.DynamicFeeTxType { - return fmt.Errorf("%w: type %d rejected, pool not yet in London", core.ErrTxTypeNotSupported, tx.Type()) + return fmt.Errorf("%w: type %d rejected, pool not yet in Curie", core.ErrTxTypeNotSupported, tx.Type()) } if !opts.Config.IsCancun(head.Number, head.Time) && tx.Type() == types.BlobTxType { return fmt.Errorf("%w: type %d rejected, pool not yet in Cancun", core.ErrTxTypeNotSupported, tx.Type()) diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go index 86649d0c26..b50426b5a3 100644 --- a/core/types/transaction_signing.go +++ b/core/types/transaction_signing.go @@ -40,10 +40,12 @@ type sigCache struct { func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer { var signer Signer switch { + case config.IsCurie(blockNumber): + signer = NewLondonSignerWithEIP4844(config.ChainID) case config.IsCancun(blockNumber, blockTime): signer = NewCancunSigner(config.ChainID) case config.IsLondon(blockNumber): - signer = NewLondonSigner(config.ChainID) + signer = NewLondonSignerWithEIP4844(config.ChainID) case config.IsBerlin(blockNumber): signer = NewEIP2930Signer(config.ChainID) case config.IsEIP155(blockNumber): @@ -69,7 +71,7 @@ func LatestSigner(config *params.ChainConfig) Signer { return NewCancunSigner(config.ChainID) } if config.LondonBlock != nil { - return NewLondonSigner(config.ChainID) + return NewLondonSignerWithEIP4844(config.ChainID) } if config.BerlinBlock != nil { return NewEIP2930Signer(config.ChainID) @@ -253,6 +255,75 @@ func (s cancunSigner) Hash(tx *Transaction) common.Hash { }) } +type londonSignerWithEIP4844 struct{ londonSigner } + +// NewLondonSignerWithEIP4844 returns a signer that accepts +// - EIP-4844 blob transactions +// - EIP-1559 dynamic fee transactions +// - EIP-2930 access list transactions, +// - EIP-155 replay protected transactions, and +// - legacy Homestead transactions. +func NewLondonSignerWithEIP4844(chainId *big.Int) Signer { + return londonSignerWithEIP4844{londonSigner{eip2930Signer{NewEIP155Signer(chainId)}}} +} + +func (s londonSignerWithEIP4844) Sender(tx *Transaction) (common.Address, error) { + if tx.Type() != BlobTxType { + return s.londonSigner.Sender(tx) + } + V, R, S := tx.RawSignatureValues() + // Blob txs are defined to use 0 and 1 as their recovery + // id, add 27 to become equivalent to unprotected Homestead signatures. + V = new(big.Int).Add(V, big.NewInt(27)) + if tx.ChainId().Cmp(s.chainId) != 0 { + return common.Address{}, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, tx.ChainId(), s.chainId) + } + return recoverPlain(s.Hash(tx), R, S, V, true) +} + +func (s londonSignerWithEIP4844) Equal(s2 Signer) bool { + x, ok := s2.(londonSignerWithEIP4844) + return ok && x.chainId.Cmp(s.chainId) == 0 +} + +func (s londonSignerWithEIP4844) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error) { + txdata, ok := tx.inner.(*BlobTx) + if !ok { + return s.londonSigner.SignatureValues(tx, sig) + } + // Check that chain ID of tx matches the signer. We also accept ID zero here, + // because it indicates that the chain ID was not specified in the tx. + if txdata.ChainID.Sign() != 0 && txdata.ChainID.ToBig().Cmp(s.chainId) != 0 { + return nil, nil, nil, fmt.Errorf("%w: have %d want %d", ErrInvalidChainId, txdata.ChainID, s.chainId) + } + R, S, _ = decodeSignature(sig) + V = big.NewInt(int64(sig[64])) + return R, S, V, nil +} + +// Hash returns the hash to be signed by the sender. +// It does not uniquely identify the transaction. +func (s londonSignerWithEIP4844) Hash(tx *Transaction) common.Hash { + if tx.Type() != BlobTxType { + return s.londonSigner.Hash(tx) + } + return prefixedRlpHash( + tx.Type(), + []interface{}{ + s.chainId, + tx.Nonce(), + tx.GasTipCap(), + tx.GasFeeCap(), + tx.Gas(), + tx.To(), + tx.Value(), + tx.Data(), + tx.AccessList(), + tx.BlobGasFeeCap(), + tx.BlobHashes(), + }) +} + type londonSigner struct{ eip2930Signer } // NewLondonSigner returns a signer that accepts diff --git a/core/vm/contracts.go b/core/vm/contracts.go index 83e1f68552..7293f4215b 100644 --- a/core/vm/contracts.go +++ b/core/vm/contracts.go @@ -97,20 +97,6 @@ var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{9}): &blake2F{}, } -// PrecompiledContractsArchimedes contains the default set of pre-compiled Ethereum -// contracts used in the Archimedes release. Same as Berlin but without sha2, blake2f, ripemd160 -var PrecompiledContractsArchimedes = map[common.Address]PrecompiledContract{ - common.BytesToAddress([]byte{1}): &ecrecover{}, - common.BytesToAddress([]byte{2}): &sha256hashDisabled{}, - common.BytesToAddress([]byte{3}): &ripemd160hashDisabled{}, - common.BytesToAddress([]byte{4}): &dataCopy{}, - common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, - common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, - common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, - common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, - common.BytesToAddress([]byte{9}): &blake2FDisabled{}, -} - // PrecompiledContractsCancun contains the default set of pre-compiled Ethereum // contracts used in the Cancun release. var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{ @@ -140,9 +126,38 @@ var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{18}): &bls12381MapG2{}, } +// PrecompiledContractsArchimedes contains the default set of pre-compiled Ethereum +// contracts used in the Archimedes release. Same as Berlin but without sha2, blake2f, ripemd160 +var PrecompiledContractsArchimedes = map[common.Address]PrecompiledContract{ + common.BytesToAddress([]byte{1}): &ecrecover{}, + common.BytesToAddress([]byte{2}): &sha256hashDisabled{}, + common.BytesToAddress([]byte{3}): &ripemd160hashDisabled{}, + common.BytesToAddress([]byte{4}): &dataCopy{}, + common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + common.BytesToAddress([]byte{9}): &blake2FDisabled{}, +} + +// PrecompiledContractsBernoulli contains the default set of pre-compiled Ethereum +// contracts used in the Bernoulli release. Same as Archimedes but with sha256hash enabled again +var PrecompiledContractsBernoulli = map[common.Address]PrecompiledContract{ + common.BytesToAddress([]byte{1}): &ecrecover{}, + common.BytesToAddress([]byte{2}): &sha256hash{}, + common.BytesToAddress([]byte{3}): &ripemd160hashDisabled{}, + common.BytesToAddress([]byte{4}): &dataCopy{}, + common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true}, + common.BytesToAddress([]byte{6}): &bn256AddIstanbul{}, + common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{}, + common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{}, + common.BytesToAddress([]byte{9}): &blake2FDisabled{}, +} + var ( - PrecompiledAddressesCancun []common.Address + PrecompiledAddressesBernoulli []common.Address PrecompiledAddressesArchimedes []common.Address + PrecompiledAddressesCancun []common.Address PrecompiledAddressesBerlin []common.Address PrecompiledAddressesIstanbul []common.Address PrecompiledAddressesByzantium []common.Address @@ -168,15 +183,23 @@ func init() { for k := range PrecompiledContractsCancun { PrecompiledAddressesCancun = append(PrecompiledAddressesCancun, k) } + for k := range PrecompiledContractsArchimedes { + PrecompiledAddressesArchimedes = append(PrecompiledAddressesArchimedes, k) + } + for k := range PrecompiledContractsBernoulli { + PrecompiledAddressesBernoulli = append(PrecompiledAddressesBernoulli, k) + } } // ActivePrecompiles returns the precompiles enabled with the current configuration. func ActivePrecompiles(rules params.Rules) []common.Address { switch { - case rules.IsCancun: - return PrecompiledAddressesCancun + case rules.IsBernoulli: + return PrecompiledAddressesBernoulli case rules.IsArchimedes: return PrecompiledAddressesArchimedes + case rules.IsCancun: + return PrecompiledAddressesCancun case rules.IsBerlin: return PrecompiledAddressesBerlin case rules.IsIstanbul: diff --git a/core/vm/eips.go b/core/vm/eips.go index 35f0a3f7c2..669b612701 100644 --- a/core/vm/eips.go +++ b/core/vm/eips.go @@ -27,7 +27,7 @@ import ( var activators = map[int]func(*JumpTable){ 5656: enable5656, - 6780: enable6780, + // 6780: enable6780, // SELFDESTRUCT is disabled in Scroll 3855: enable3855, 3860: enable3860, 3529: enable3529, @@ -147,10 +147,9 @@ func enable2929(jt *JumpTable) { jt[DELEGATECALL].constantGas = params.WarmStorageReadCostEIP2929 jt[DELEGATECALL].dynamicGas = gasDelegateCallEIP2929 - // This was previously part of the dynamic cost, but we're using it as a constantGas - // factor here - jt[SELFDESTRUCT].constantGas = params.SelfdestructGasEIP150 - jt[SELFDESTRUCT].dynamicGas = gasSelfdestructEIP2929 + // SELFDESTRUCT is disabled in Scroll + // jt[SELFDESTRUCT].constantGas = params.SelfdestructGasEIP150 + // jt[SELFDESTRUCT].dynamicGas = gasSelfdestructEIP2929 } // enable3529 enabled "EIP-3529: Reduction in refunds": @@ -159,7 +158,9 @@ func enable2929(jt *JumpTable) { // - Reduces max refunds to 20% gas func enable3529(jt *JumpTable) { jt[SSTORE].dynamicGas = gasSStoreEIP3529 - jt[SELFDESTRUCT].dynamicGas = gasSelfdestructEIP3529 + + // SELFDESTRUCT is disabled in Scroll + // jt[SELFDESTRUCT].dynamicGas = gasSelfdestructEIP3529 } // enable3198 applies EIP-3198 (BASEFEE Opcode) @@ -309,6 +310,8 @@ func enable7516(jt *JumpTable) { } } +// SELFDESTRUCT is disabled in Scroll. +/* // enable6780 applies EIP-6780 (deactivate SELFDESTRUCT) func enable6780(jt *JumpTable) { jt[SELFDESTRUCT] = &operation{ @@ -319,3 +322,4 @@ func enable6780(jt *JumpTable) { maxStack: maxStack(1, 0), } } +*/ diff --git a/core/vm/evm.go b/core/vm/evm.go index 680424283a..e4a6f5e204 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -40,10 +40,12 @@ type ( func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) { var precompiles map[common.Address]PrecompiledContract switch { - case evm.chainRules.IsCancun: - precompiles = PrecompiledContractsCancun + case evm.chainRules.IsBernoulli: + precompiles = PrecompiledContractsBernoulli case evm.chainRules.IsArchimedes: precompiles = PrecompiledContractsArchimedes + case evm.chainRules.IsCancun: + precompiles = PrecompiledContractsCancun case evm.chainRules.IsBerlin: precompiles = PrecompiledContractsBerlin case evm.chainRules.IsIstanbul: diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index 4b141d8f9a..8bc824ecdf 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -455,6 +455,8 @@ func gasStaticCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memo return gas, nil } +// SELFDESTRUCT is disabled in Scroll. +/* func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { var gas uint64 // EIP150 homestead gas reprice fork: @@ -477,3 +479,4 @@ func gasSelfdestruct(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me } return gas, nil } +*/ diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index 160811fbbb..c9627ac693 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -56,6 +56,10 @@ func NewEVMInterpreter(evm *EVM) *EVMInterpreter { // If jump table was not initialised we set the default one. var table *JumpTable switch { + case evm.chainRules.IsDescartes: + table = &descartesInstructionSet + case evm.chainRules.IsCurie: + table = &curieInstructionSet case evm.chainRules.IsCancun: table = &cancunInstructionSet case evm.chainRules.IsShanghai: diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go index fb87258326..2acd7b3e31 100644 --- a/core/vm/jump_table.go +++ b/core/vm/jump_table.go @@ -57,6 +57,8 @@ var ( mergeInstructionSet = newMergeInstructionSet() shanghaiInstructionSet = newShanghaiInstructionSet() cancunInstructionSet = newCancunInstructionSet() + curieInstructionSet = newCurieInstructionSet() + descartesInstructionSet = newDescartesInstructionSet() ) // JumpTable contains the EVM opcodes supported at a given fork. @@ -80,13 +82,31 @@ func validate(jt JumpTable) JumpTable { return jt } +// newDescartesInstructionSet returns the frontier, homestead, byzantium, +// contantinople, istanbul, petersburg, berlin, london, shanghai, curie, and descartes instructions. +func newDescartesInstructionSet() JumpTable { + instructionSet := newCurieInstructionSet() + return instructionSet +} + +// newCurieInstructionSet returns the frontier, homestead, byzantium, +// contantinople, istanbul, petersburg, berlin, london, shanghai, and curie instructions. +func newCurieInstructionSet() JumpTable { + instructionSet := newShanghaiInstructionSet() + enable3198(&instructionSet) // Base fee opcode https://eips.ethereum.org/EIPS/eip-3198 + enable5656(&instructionSet) // EIP-5656 (MCOPY opcode) + enable1153(&instructionSet) // EIP-1153 (TLOAD, TSTORE opcodes) + return instructionSet +} + func newCancunInstructionSet() JumpTable { instructionSet := newShanghaiInstructionSet() enable4844(&instructionSet) // EIP-4844 (BLOBHASH opcode) enable7516(&instructionSet) // EIP-7516 (BLOBBASEFEE opcode) enable1153(&instructionSet) // EIP-1153 "Transient Storage" enable5656(&instructionSet) // EIP-5656 (MCOPY opcode) - enable6780(&instructionSet) // EIP-6780 SELFDESTRUCT only in same transaction + // SELFDESTRUCT is disabled in Scroll. + // enable6780(&instructionSet) // EIP-6780 SELFDESTRUCT only in same transaction return validate(instructionSet) } @@ -114,7 +134,7 @@ func newMergeInstructionSet() JumpTable { func newLondonInstructionSet() JumpTable { instructionSet := newBerlinInstructionSet() enable3529(&instructionSet) // EIP-3529: Reduction in refunds https://eips.ethereum.org/EIPS/eip-3529 - enable3198(&instructionSet) // Base fee opcode https://eips.ethereum.org/EIPS/eip-3198 + // enable3198(&instructionSet) // Base fee opcode https://eips.ethereum.org/EIPS/eip-3198 return validate(instructionSet) } @@ -1046,12 +1066,9 @@ func newFrontierInstructionSet() JumpTable { maxStack: maxStack(2, 0), memorySize: memoryReturn, }, - SELFDESTRUCT: { - execute: opSelfdestruct, - dynamicGas: gasSelfdestruct, - minStack: minStack(1, 0), - maxStack: maxStack(1, 0), - }, + // SELFDESTRUCT is disabled in Scroll. + // SELFDESTRUCT has the same behavior as INVALID. + SELFDESTRUCT: nil, } // Fill all unassigned slots with opUndefined. diff --git a/core/vm/opcodes.go b/core/vm/opcodes.go index a11cf05a15..9ab04642e3 100644 --- a/core/vm/opcodes.go +++ b/core/vm/opcodes.go @@ -286,7 +286,12 @@ var opCodeToString = map[OpCode]string{ GASLIMIT: "GASLIMIT", CHAINID: "CHAINID", SELFBALANCE: "SELFBALANCE", - BASEFEE: "BASEFEE", + + // we temporarily comment this out, since ccc expects + // the "opcode 0x%x not defined" string in the traces, + // should uncomment once ccc supports the string version. + // BASEFEE: "BASEFEE", + BLOBHASH: "BLOBHASH", BLOBBASEFEE: "BLOBBASEFEE", @@ -303,10 +308,15 @@ var opCodeToString = map[OpCode]string{ MSIZE: "MSIZE", GAS: "GAS", JUMPDEST: "JUMPDEST", - TLOAD: "TLOAD", - TSTORE: "TSTORE", - MCOPY: "MCOPY", - PUSH0: "PUSH0", + + // we temporarily comment these out, since ccc expects + // the "opcode 0x%x not defined" string in the traces, + // should uncomment once ccc supports the string version. + // TLOAD: "TLOAD", + // TSTORE: "TSTORE", + // MCOPY: "MCOPY", + + PUSH0: "PUSH0", // 0x60 range - pushes. PUSH1: "PUSH1", diff --git a/core/vm/operations_acl.go b/core/vm/operations_acl.go index 04c6409ebd..4d01392735 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -196,9 +196,10 @@ var ( gasDelegateCallEIP2929 = makeCallVariantGasCallEIP2929(gasDelegateCall) gasStaticCallEIP2929 = makeCallVariantGasCallEIP2929(gasStaticCall) gasCallCodeEIP2929 = makeCallVariantGasCallEIP2929(gasCallCode) - gasSelfdestructEIP2929 = makeSelfdestructGasFn(true) - // gasSelfdestructEIP3529 implements the changes in EIP-2539 (no refunds) - gasSelfdestructEIP3529 = makeSelfdestructGasFn(false) + // SELFDESTRUCT is disabled in Scroll. + // gasSelfdestructEIP2929 = makeSelfdestructGasFn(true) + // // gasSelfdestructEIP3529 implements the changes in EIP-2539 (no refunds) + // gasSelfdestructEIP3529 = makeSelfdestructGasFn(false) // gasSStoreEIP2929 implements gas cost for SSTORE according to EIP-2929 // @@ -219,6 +220,8 @@ var ( gasSStoreEIP3529 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP3529) ) +// SELFDESTRUCT is disabled in Scroll. +/* // makeSelfdestructGasFn can create the selfdestruct dynamic gas function for EIP-2929 and EIP-2539 func makeSelfdestructGasFn(refundsEnabled bool) gasFunc { gasFunc := func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { @@ -242,3 +245,4 @@ func makeSelfdestructGasFn(refundsEnabled bool) gasFunc { } return gasFunc } +*/ diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index 2a42bf8ec5..f42c3fcee6 100644 --- a/core/vm/runtime/runtime.go +++ b/core/vm/runtime/runtime.go @@ -71,6 +71,10 @@ func setDefaults(cfg *Config) { BerlinBlock: new(big.Int), LondonBlock: new(big.Int), ArchimedesBlock: new(big.Int), + ShanghaiTime: new(uint64), + BernoulliBlock: new(big.Int), + CurieBlock: new(big.Int), + DescartesBlock: new(big.Int), } } diff --git a/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go index 6717e61327..9bd9053968 100644 --- a/eth/tracers/js/tracer_test.go +++ b/eth/tracers/js/tracer_test.go @@ -233,6 +233,7 @@ func TestIsPrecompile(t *testing.T) { chaincfg.ByzantiumBlock = big.NewInt(100) chaincfg.IstanbulBlock = big.NewInt(200) chaincfg.BerlinBlock = big.NewInt(300) + chaincfg.ArchimedesBlock = big.NewInt(400) txCtx := vm.TxContext{GasPrice: big.NewInt(100000)} tracer, err := newJsTracer("{addr: toAddress('0000000000000000000000000000000000000009'), res: null, step: function() { this.res = isPrecompiled(this.addr); }, fault: function() {}, result: function() { return this.res; }}", nil, nil) if err != nil { @@ -257,6 +258,47 @@ func TestIsPrecompile(t *testing.T) { if string(res) != "true" { t.Errorf("tracer should consider blake2f as precompile in istanbul") } + + // test sha disabled in archimedes + tracer, _ = newJsTracer("{addr: toAddress('0000000000000000000000000000000000000002'), res: null, step: function() { this.res = isPrecompiled(this.addr); }, fault: function() {}, result: function() { return this.res; }}", nil) + blockCtx = vm.BlockContext{BlockNumber: big.NewInt(450)} + res, err = runTrace(tracer, &vmContext{blockCtx, txCtx}, chaincfg) + if err != nil { + t.Error(err) + } + if string(res) != "false" { + t.Errorf("Tracer should not consider blake2f as precompile in archimedes") + } + + tracer, _ = newJsTracer("{addr: toAddress('0000000000000000000000000000000000000003'), res: null, step: function() { this.res = isPrecompiled(this.addr); }, fault: function() {}, result: function() { return this.res; }}", nil) + blockCtx = vm.BlockContext{BlockNumber: big.NewInt(450)} + res, err = runTrace(tracer, &vmContext{blockCtx, txCtx}, chaincfg) + if err != nil { + t.Error(err) + } + if string(res) != "false" { + t.Errorf("Tracer should not consider ripemd as precompile in archimedes") + } + + // test blake2f disabled in archimedes + tracer, _ = newJsTracer("{addr: toAddress('0000000000000000000000000000000000000009'), res: null, step: function() { this.res = isPrecompiled(this.addr); }, fault: function() {}, result: function() { return this.res; }}", nil) + res, err = runTrace(tracer, &vmContext{blockCtx, txCtx}, chaincfg) + if err != nil { + t.Error(err) + } + if string(res) != "false" { + t.Errorf("Tracer should not consider blake2f as precompile in archimedes") + } + + // test ecrecover enabled in archimedes + tracer, _ = newJsTracer("{addr: toAddress('0000000000000000000000000000000000000001'), res: null, step: function() { this.res = isPrecompiled(this.addr); }, fault: function() {}, result: function() { return this.res; }}", nil) + res, err = runTrace(tracer, &vmContext{blockCtx, txCtx}, chaincfg) + if err != nil { + t.Error(err) + } + if string(res) != "true" { + t.Errorf("Tracer should keep ecrecover as precompile in archimedes") + } } func TestEnterExit(t *testing.T) { diff --git a/tests/init.go b/tests/init.go index 99b7e4d333..3526f59344 100644 --- a/tests/init.go +++ b/tests/init.go @@ -337,6 +337,41 @@ var Forks = map[string]*params.ChainConfig{ ShanghaiTime: u64(0), CancunTime: u64(15_000), }, + "Archimedes": { + ChainID: big.NewInt(1), + HomesteadBlock: big.NewInt(0), + EIP150Block: big.NewInt(0), + EIP155Block: big.NewInt(0), + EIP158Block: big.NewInt(0), + ByzantiumBlock: big.NewInt(0), + ConstantinopleBlock: big.NewInt(0), + PetersburgBlock: big.NewInt(0), + IstanbulBlock: big.NewInt(0), + MuirGlacierBlock: big.NewInt(0), + BerlinBlock: big.NewInt(0), + LondonBlock: big.NewInt(0), + ArrowGlacierBlock: big.NewInt(0), + ArchimedesBlock: big.NewInt(0), + }, + "Curie": { + ChainID: big.NewInt(1), + HomesteadBlock: big.NewInt(0), + EIP150Block: big.NewInt(0), + EIP155Block: big.NewInt(0), + EIP158Block: big.NewInt(0), + ByzantiumBlock: big.NewInt(0), + ConstantinopleBlock: big.NewInt(0), + PetersburgBlock: big.NewInt(0), + IstanbulBlock: big.NewInt(0), + MuirGlacierBlock: big.NewInt(0), + BerlinBlock: big.NewInt(0), + LondonBlock: big.NewInt(0), + ArrowGlacierBlock: big.NewInt(0), + ArchimedesBlock: big.NewInt(0), + ShanghaiTime: u64(0), + BernoulliBlock: big.NewInt(0), + CurieBlock: big.NewInt(0), + }, } // AvailableForks returns the set of defined fork names diff --git a/tests/state_test_util.go b/tests/state_test_util.go index f90d6d2d70..9556c628eb 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -240,7 +240,7 @@ func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapsh triedb, snaps, statedb := MakePreState(rawdb.NewMemoryDatabase(), t.json.Pre, snapshotter, scheme) var baseFee *big.Int - if config.IsLondon(new(big.Int)) { + if config.IsCurie(new(big.Int)) { baseFee = t.json.Env.BaseFee if baseFee == nil { // Retesteth uses `0x10` for genesis baseFee. Therefore, it defaults to