[evm] EIP-1153 enable transient storage feature

action/protocol/execution/evm/evm.go

@@ -447,6 +447,12 @@ func getChainConfig(g genesis.Blockchain, height uint64, id uint32, getBlockTime
 	}
 	sumatraTimestamp := (uint64)(sumatraTime.Unix())
 	chainConfig.ShanghaiTime = &sumatraTimestamp
+	upernavikTime, err := getBlockTime(g.UpernavikBlockHeight)
+	if err != nil {
+		return nil, err
+	}
+	upernavikTimestamp := (uint64)(upernavikTime.Unix())
+	chainConfig.CancunTime = &upernavikTimestamp
 	return &chainConfig, nil
 }
 

action/protocol/execution/evm/evm_test.go

@@ -259,7 +259,7 @@ func TestConstantinople(t *testing.T) {
 		},
 		{
 			"io1pcg2ja9krrhujpazswgz77ss46xgt88afqlk6y",
-			1261440000, // = 200*365*24*3600/5, around 200 years later
+			39275560,
 		},
 	}
 	now := time.Now()

action/protocol/execution/evm/evmstatedbadapter.go

@@ -43,24 +43,27 @@
 
 	// StateDBAdapter represents the state db adapter for evm to access iotx blockchain
 	StateDBAdapter struct {
-		sm                         protocol.StateManager
-		logs                       []*action.Log
-		transactionLogs            []*action.TransactionLog
-		err                        error
-		blockHeight                uint64
-		executionHash              hash.Hash256
-		lastAddBalanceAddr         string
-		lastAddBalanceAmount       *big.Int
-		refund                     uint64
-		refundSnapshot             map[int]uint64
-		cachedContract             contractMap
-		contractSnapshot           map[int]contractMap   // snapshots of contracts
-		suicided                   deleteAccount         // account/contract calling Suicide
-		suicideSnapshot            map[int]deleteAccount // snapshots of suicide accounts
-		preimages                  preimageMap
-		preimageSnapshot           map[int]preimageMap
-		accessList                 *accessList // per-transaction access list
-		accessListSnapshot         map[int]*accessList
+		sm                   protocol.StateManager
+		logs                 []*action.Log
+		transactionLogs      []*action.TransactionLog
+		err                  error
+		blockHeight          uint64
+		executionHash        hash.Hash256
+		lastAddBalanceAddr   string
+		lastAddBalanceAmount *big.Int
+		refund               uint64
+		refundSnapshot       map[int]uint64
+		cachedContract       contractMap
+		contractSnapshot     map[int]contractMap   // snapshots of contracts
+		suicided             deleteAccount         // account/contract calling Suicide
+		suicideSnapshot      map[int]deleteAccount // snapshots of suicide accounts
+		preimages            preimageMap
+		preimageSnapshot     map[int]preimageMap
+		accessList           *accessList // per-transaction access list
+		accessListSnapshot   map[int]*accessList
+		// Transient storage
+		transientStorage           transientStorage
+		transientStorageSnapshot   map[int]transientStorage
 		logsSnapshot               map[int]int // logs is an array, save len(logs) at time of snapshot suffices
 		txLogsSnapshot             map[int]int
 		notFixTopicCopyBug         bool
@@ -170,23 +173,25 @@
 	opts ...StateDBAdapterOption,
 ) (*StateDBAdapter, error) {
 	s := &StateDBAdapter{
-		sm:                   sm,
-		logs:                 []*action.Log{},
-		err:                  nil,
-		blockHeight:          blockHeight,
-		executionHash:        executionHash,
-		lastAddBalanceAmount: new(big.Int),
-		refundSnapshot:       make(map[int]uint64),
-		cachedContract:       make(contractMap),
-		contractSnapshot:     make(map[int]contractMap),
-		suicided:             make(deleteAccount),
-		suicideSnapshot:      make(map[int]deleteAccount),
-		preimages:            make(preimageMap),
-		preimageSnapshot:     make(map[int]preimageMap),
-		accessList:           newAccessList(),
-		accessListSnapshot:   make(map[int]*accessList),
-		logsSnapshot:         make(map[int]int),
-		txLogsSnapshot:       make(map[int]int),
+		sm:                       sm,
+		logs:                     []*action.Log{},
+		err:                      nil,
+		blockHeight:              blockHeight,
+		executionHash:            executionHash,
+		lastAddBalanceAmount:     new(big.Int),
+		refundSnapshot:           make(map[int]uint64),
+		cachedContract:           make(contractMap),
+		contractSnapshot:         make(map[int]contractMap),
+		suicided:                 make(deleteAccount),
+		suicideSnapshot:          make(map[int]deleteAccount),
+		preimages:                make(preimageMap),
+		preimageSnapshot:         make(map[int]preimageMap),
+		accessList:               newAccessList(),
+		accessListSnapshot:       make(map[int]*accessList),
+		transientStorage:         newTransientStorage(),
+		transientStorageSnapshot: make(map[int]transientStorage),
+		logsSnapshot:             make(map[int]int),
+		txLogsSnapshot:           make(map[int]int),
 	}
 	for _, opt := range opts {
 		if err := opt(s); err != nil {
@@ -478,13 +483,22 @@
 
 // SetTransientState sets transient storage for a given account
 func (stateDB *StateDBAdapter) SetTransientState(addr common.Address, key, value common.Hash) {
-	log.S().Panic("SetTransientState not implemented")
+	prev := stateDB.GetTransientState(addr, key)
+	if prev == value {
+		return
+	}
+	stateDB.setTransientState(addr, key, value)
+}
+
+// setTransientState is a lower level setter for transient storage. It
+// is called during a revert to prevent modifications to the journal.
+func (stateDB *StateDBAdapter) setTransientState(addr common.Address, key, value common.Hash) {
+	stateDB.transientStorage.Set(addr, key, value)
 }
 
 // GetTransientState gets transient storage for a given account.
 func (stateDB *StateDBAdapter) GetTransientState(addr common.Address, key common.Hash) common.Hash {
-	log.S().Panic("GetTransientState not implemented")
-	return common.Hash{}
+	return stateDB.transientStorage.Get(addr, key)
 }
 
 // Selfdestruct6780 implements EIP-6780
@@ -530,6 +544,8 @@
 	if !rules.IsBerlin {
 		return
 	}
+	// Clear out any leftover from previous executions
+	stateDB.accessList = newAccessList()
 	stateDB.AddAddressToAccessList(sender)
 	if dst != nil {
 		stateDB.AddAddressToAccessList(*dst)
@@ -547,6 +563,8 @@
 	if rules.IsShanghai { // EIP-3651: warm coinbase
 		stateDB.AddAddressToAccessList(coinbase)
 	}
+	// Reset transient storage at the beginning of transaction execution
+	stateDB.transientStorage = newTransientStorage()
 }
 
 // AddressInAccessList returns true if the given address is in the access list
@@ -592,6 +610,23 @@
 		stateDB.logError(err)
 		return
 	}
+	// restore transientStorage
+	tss, ok := stateDB.transientStorageSnapshot[snapshot]
+	if !ok {
+		log.L().Error("unexpected error: missing transient storage snapshot")
+		return
+	}
+	stateDB.transientStorage = tss
+	{
+		delete(stateDB.transientStorageSnapshot, snapshot)
+		for i := snapshot + 1; ; i++ {
+			if _, ok := stateDB.transientStorageSnapshot[i]; ok {
+				delete(stateDB.transientStorageSnapshot, i)
+			} else {
+				break
+			}
+		}
+	}
 	ds, ok := stateDB.suicideSnapshot[snapshot]
 	if !ok {
 		// this should not happen, b/c we save the suicide accounts on a successful return of Snapshot(), but check anyway
@@ -750,6 +785,7 @@
 	stateDB.preimageSnapshot[sn] = p
 	// save a copy of access list
 	stateDB.accessListSnapshot[sn] = stateDB.accessList.Copy()
+	stateDB.transientStorageSnapshot[sn] = stateDB.transientStorage.Copy()
 	return sn
 }
 
@@ -1089,6 +1125,8 @@
 	stateDB.preimageSnapshot = make(map[int]preimageMap)
 	stateDB.accessList = newAccessList()
 	stateDB.accessListSnapshot = make(map[int]*accessList)
+	stateDB.transientStorage = newTransientStorage()
+	stateDB.transientStorageSnapshot = make(map[int]transientStorage)
 	stateDB.logsSnapshot = make(map[int]int)
 	stateDB.txLogsSnapshot = make(map[int]int)
 	stateDB.logs = []*action.Log{}

action/protocol/execution/evm/evmstatedbadapter_test.go

@@ -934,3 +934,45 @@ func TestSortMap(t *testing.T) {
 		require.True(testFunc(t, sm))
 	})
 }
+
+func TestStateDBTransientStorage(t *testing.T) {
+	require := require.New(t)
+	ctrl := gomock.NewController(t)
+	sm, err := initMockStateManager(ctrl)
+	require.NoError(err)
+	var opts []StateDBAdapterOption
+	opts = append(opts,
+		NotFixTopicCopyBugOption(),
+		FixSnapshotOrderOption(),
+	)
+	state, err := NewStateDBAdapter(sm, 1, hash.ZeroHash256, opts...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	key := common.Hash{0x01}
+	value := common.Hash{0x02}
+	addr := common.Address{}
+
+	sn := state.Snapshot()
+	state.SetTransientState(addr, key, value)
+	if exp, got := 0, sn; exp != got {
+		t.Fatalf("journal length mismatch: have %d, want %d", got, exp)
+	}
+	// the retrieved value should equal what was set
+	if got := state.GetTransientState(addr, key); got != value {
+		t.Fatalf("transient storage mismatch: have %x, want %x", got, value)
+	}
+
+	// revert the transient state being set and then check that the
+	// value is now the empty hash
+	state.RevertToSnapshot(sn)
+	if got, exp := state.GetTransientState(addr, key), (common.Hash{}); exp != got {
+		t.Fatalf("transient storage mismatch: have %x, want %x", got, exp)
+	}
+
+	// reset transient state
+	state.SetTransientState(addr, key, value)
+	if got := state.GetTransientState(addr, key); got != value {
+		t.Fatalf("transient storage mismatch: have %x, want %x", got, value)
+	}
+}

action/protocol/execution/protocol_test.go

@@ -71,6 +71,7 @@ type (
 		IsIceland  bool `json:"isIceland"`
 		IsLondon   bool `json:"isLondon"`
 		IsShanghai bool `json:"isShanghai"`
+		IsCancun   bool `json:"isCancun"`
 	}
 
 	Log struct {
@@ -437,6 +438,9 @@ func (sct *SmartContractTest) prepareBlockchain(
 		cfg.Genesis.Blockchain.SumatraBlockHeight = 0
 		cfg.Genesis.ActionGasLimit = 10000000
 	}
+	if sct.InitGenesis.IsCancun {
+		cfg.Genesis.Blockchain.UpernavikBlockHeight = 0
+	}
 	for _, expectedBalance := range sct.InitBalances {
 		cfg.Genesis.InitBalanceMap[expectedBalance.Account] = expectedBalance.Balance().String()
 	}
@@ -1321,6 +1325,12 @@ func TestShanghaiEVM(t *testing.T) {
 	})
 }
 
+func TestCancunEVM(t *testing.T) {
+	t.Run("eip1153-transientstorage", func(t *testing.T) {
+		NewSmartContractTest(t, "testdata-cancun/transientstorage.json")
+	})
+}
+
 func benchmarkHotContractWithFactory(b *testing.B, async bool) {
 	sct := SmartContractTest{
 		InitBalances: []ExpectedBalance{

action/protocol/execution/testdata-cancun/transientstorage.json

@@ -0,0 +1,49 @@
+{
+    "initGenesis": {
+        "isBering" : true,
+        "isIceland" : true,
+        "isLondon" : true,
+        "isShanghai" : true,
+        "isCancun": true
+    },
+    "initBalances": [{
+        "account": "io1mflp9m6hcgm2qcghchsdqj3z3eccrnekx9p0ms",
+        "rawBalance": "1000000000000000000000000000"
+    }],
+    "deployments": [{
+        "rawByteCode": "608060405234801561000f575f80fd5b506102898061001d5f395ff3fe608060405234801561000f575f80fd5b506004361061004a575f3560e01c80630198214f1461004e57806338cc48311461006a5780639c6f010c14610088578063f2c9ecd8146100b8575b5f80fd5b6100686004803603810190610063919061016a565b6100d6565b005b6100726100dd565b60405161007f91906101e7565b60405180910390f35b6100a2600480360381019061009d9190610200565b61010f565b6040516100af919061023a565b60405180910390f35b6100c0610119565b6040516100cd919061023a565b60405180910390f35b80825d5050565b5f6101006001600373ffffffffffffffffffffffffffffffffffffffff166100d6565b61010a600161010f565b905090565b5f815c9050919050565b5f6101255f60216100d6565b61012e5f61010f565b905090565b5f80fd5b5f819050919050565b61014981610137565b8114610153575f80fd5b50565b5f8135905061016481610140565b92915050565b5f80604083850312156101805761017f610133565b5b5f61018d85828601610156565b925050602061019e85828601610156565b9150509250929050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6101d1826101a8565b9050919050565b6101e1816101c7565b82525050565b5f6020820190506101fa5f8301846101d8565b92915050565b5f6020828403121561021557610214610133565b5b5f61022284828501610156565b91505092915050565b61023481610137565b82525050565b5f60208201905061024d5f83018461022b565b9291505056fea2646970667358221220482553b58e8f517e223d2d9d4345c179916b57ace9585c2ff1965520d3a2221064736f6c63430008180033",
+        "rawPrivateKey": "cfa6ef757dee2e50351620dca002d32b9c090cfda55fb81f37f1d26b273743f1",
+        "rawAmount": "0",
+        "rawGasLimit": 5000000,
+        "rawGasPrice": "0",
+        "rawExpectedGasConsumed": 207775,
+        "expectedStatus": 1,
+        "expectedBalances": [],
+        "comment": "deploy transientstore contract"
+    }],
+    "executions": [{
+        "rawPrivateKey": "cfa6ef757dee2e50351620dca002d32b9c090cfda55fb81f37f1d26b273743f1",
+        "rawByteCode": "f2c9ecd8",
+        "rawAmount": "0",
+        "rawGasLimit": 1000000,
+        "rawGasPrice": "0",
+        "rawAccessList": [],
+        "rawExpectedGasConsumed": 11056,
+        "expectedStatus": 1,
+        "readOnly": true,
+        "rawReturnValue": "0000000000000000000000000000000000000000000000000000000000000021",
+        "comment": "call getNumber"
+    },{
+        "rawPrivateKey": "cfa6ef757dee2e50351620dca002d32b9c090cfda55fb81f37f1d26b273743f1",
+        "rawByteCode": "38cc4831",
+        "rawAmount": "0",
+        "rawGasLimit": 1000000,
+        "rawGasPrice": "0",
+        "rawAccessList": [],
+        "rawExpectedGasConsumed": 11068,
+        "expectedStatus": 1,
+        "readOnly": true,
+        "rawReturnValue": "0000000000000000000000000000000000000000000000000000000000000003",
+        "comment": "call getAddress"
+    }]
+}

action/protocol/execution/testdata-cancun/transientstorage.sol

@@ -0,0 +1,30 @@
+// This support was introduced with Solidity 0.8.24
+pragma solidity 0.8.24;
+// SPDX-License-Identifier: Unlicensed
+
+contract TransientStorage {
+
+    // Sets a number in the transient storage
+    function getNumber() public returns (uint) {
+        tstore(0, uint(33));
+        return uint(tload(0));
+    }
+
+    // Sets an address in the transient storage
+    function getAddress() public returns (address) {
+        tstore(1, uint(uint160(address(3))));
+        return address(uint160(tload(1)));
+    }
+
+    function tstore(uint location, uint value) public {
+        assembly {
+            tstore(location, value)
+        }
+    }
+
+    function tload(uint location) public view returns (uint value) {
+        assembly {
+            value := tload(location)
+        }
+    }
+}