From 445feaeef58bd89a113743dccf6fd5df55cde6fa Mon Sep 17 00:00:00 2001 From: Jeffrey Wilcke Date: Thu, 20 Oct 2016 13:36:29 +0200 Subject: core, core/state, trie: EIP158, reprice & skip empty account write This commit implements EIP158 part 1, 2, 3 & 4 1. If an account is empty it's no longer written to the trie. An empty account is defined as (balance=0, nonce=0, storage=0, code=0). 2. Delete an empty account if it's touched 3. An empty account is redefined as either non-existent or empty. 4. Zero value calls and zero value suicides no longer consume the 25k reation costs. params: moved core/config to params Signed-off-by: Jeffrey Wilcke --- tests/state_test.go | 325 ++++++++++++++++++++++++++++------------------------ 1 file changed, 177 insertions(+), 148 deletions(-) (limited to 'tests/state_test.go') diff --git a/tests/state_test.go b/tests/state_test.go index 1e848ab4e..b266c2215 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -21,6 +21,8 @@ import ( "os" "path/filepath" "testing" + + "github.com/ethereum/go-ethereum/params" ) func BenchmarkStateCall1024(b *testing.B) { @@ -31,172 +33,172 @@ func BenchmarkStateCall1024(b *testing.B) { } func TestStateSystemOperations(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stSystemOperationsTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateExample(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stExample.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStatePreCompiledContracts(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stPreCompiledContracts.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateRecursiveCreate(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stRecursiveCreate.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateSpecial(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stSpecialTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateRefund(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stRefundTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateBlockHash(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stBlockHashTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateInitCode(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stInitCodeTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateLog(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stLogTests.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateTransaction(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stTransactionTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateTransition(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stTransitionTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestCallCreateCallCode(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stCallCreateCallCodeTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestCallCodes(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stCallCodes.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestDelegateCall(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stDelegatecallTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestMemory(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stMemoryTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestMemoryStress(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } @@ -204,13 +206,13 @@ func TestMemoryStress(t *testing.T) { t.Skip() } fn := filepath.Join(stateTestDir, "stMemoryStressTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestQuadraticComplexity(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } @@ -218,41 +220,41 @@ func TestQuadraticComplexity(t *testing.T) { t.Skip() } fn := filepath.Join(stateTestDir, "stQuadraticComplexityTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestSolidity(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stSolidityTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestWallet(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fn := filepath.Join(stateTestDir, "stWalletTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestStateTestsRandom(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: big.NewInt(1150000), } fns, _ := filepath.Glob("./files/StateTests/RandomTests/*") for _, fn := range fns { - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(fn, err) } } @@ -260,117 +262,117 @@ func TestStateTestsRandom(t *testing.T) { // homestead tests func TestHomesteadStateSystemOperations(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stSystemOperationsTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadStatePreCompiledContracts(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stPreCompiledContracts.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadStateRecursiveCreate(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stSpecialTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadStateRefund(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stRefundTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadStateInitCode(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stInitCodeTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadStateLog(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stLogTests.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadStateTransaction(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stTransactionTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadCallCreateCallCode(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stCallCreateCallCodeTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadCallCodes(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stCallCodes.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadMemory(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stMemoryTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadMemoryStress(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } @@ -378,13 +380,13 @@ func TestHomesteadMemoryStress(t *testing.T) { t.Skip() } fn := filepath.Join(stateTestDir, "Homestead", "stMemoryStressTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadQuadraticComplexity(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } @@ -392,286 +394,313 @@ func TestHomesteadQuadraticComplexity(t *testing.T) { t.Skip() } fn := filepath.Join(stateTestDir, "Homestead", "stQuadraticComplexityTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadWallet(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stWalletTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadDelegateCodes(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stCallDelegateCodes.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadDelegateCodesCallCode(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stCallDelegateCodesCallCode.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestHomesteadBounds(t *testing.T) { - ruleSet := RuleSet{ + chainConfig := ¶ms.ChainConfig{ HomesteadBlock: new(big.Int), } fn := filepath.Join(stateTestDir, "Homestead", "stBoundsTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } // EIP150 tests func TestEIP150Specific(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "stEIPSpecificTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150SingleCodeGasPrice(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "stEIPSingleCodeGasPrices.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150MemExpandingCalls(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "stMemExpandingEIPCalls.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStateSystemOperations(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stSystemOperationsTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStatePreCompiledContracts(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stPreCompiledContracts.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStateRecursiveCreate(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stSpecialTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStateRefund(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stRefundTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStateInitCode(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stInitCodeTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStateLog(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stLogTests.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadStateTransaction(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stTransactionTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadCallCreateCallCode(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallCreateCallCodeTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadCallCodes(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallCodes.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadMemory(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stMemoryTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadMemoryStress(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } if os.Getenv("TEST_VM_COMPLEX") == "" { t.Skip() } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stMemoryStressTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadQuadraticComplexity(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } if os.Getenv("TEST_VM_COMPLEX") == "" { t.Skip() } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stQuadraticComplexityTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadWallet(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stWalletTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadDelegateCodes(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallDelegateCodes.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadDelegateCodesCallCode(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stCallDelegateCodesCallCode.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } func TestEIP150HomesteadBounds(t *testing.T) { - ruleSet := RuleSet{ - HomesteadBlock: new(big.Int), - HomesteadGasRepriceBlock: big.NewInt(2457000), + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), } fn := filepath.Join(stateTestDir, "EIP150", "Homestead", "stBoundsTest.json") - if err := RunStateTest(ruleSet, fn, StateSkipTests); err != nil { + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { + t.Error(err) + } +} + +// EIP158 tests +func TestEIP158Create(t *testing.T) { + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), + EIP158Block: big.NewInt(3500000), + } + + fn := filepath.Join(stateTestDir, "EIP158", "stCreateTest.json") + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { + t.Error(err) + } +} + +func TestEIP158Specific(t *testing.T) { + chainConfig := ¶ms.ChainConfig{ + HomesteadBlock: new(big.Int), + EIP150Block: big.NewInt(2457000), + EIP158Block: big.NewInt(3500000), + } + + fn := filepath.Join(stateTestDir, "EIP158", "stEIP158SpecificTest.json") + if err := RunStateTest(chainConfig, fn, StateSkipTests); err != nil { t.Error(err) } } -- cgit v1.2.3