all: impl eip-7702

Co-authored-by: lightclient <[email protected]>
Co-authored-by: Mario Vega <[email protected]>

cmd/evm/internal/t8ntool/transaction.go

@@ -133,7 +133,7 @@ func Transaction(ctx *cli.Context) error {
  r.Address = sender
  }
  // Check intrinsic gas
- if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil,
+ if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.AuthList(), tx.To() == nil,
  chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int)), chainConfig.IsShanghai(new(big.Int), 0)); err != nil {
  r.Error = err
  results = append(results, r)

cmd/evm/staterunner.go

@@ -91,7 +91,7 @@ func runStateTest(fname string, cfg vm.Config, dump bool) error {
  }
  var testsByName map[string]tests.StateTest
  if err := json.Unmarshal(src, &testsByName); err != nil {
- return err
+ return fmt.Errorf("unable to read test file: %w", err)
  }
 
  // Iterate over all the tests, run them and aggregate the results

common/types.go

@@ -45,6 +45,9 @@ var (
  hashT = reflect.TypeOf(Hash{})
  addressT = reflect.TypeOf(Address{})
 
+ // ZeroAddress represents the zero address value.
+ ZeroAddress = Address{}
+
  // MaxAddress represents the maximum possible address value.
  MaxAddress = HexToAddress("0xffffffffffffffffffffffffffffffffffffffff")
 

core/bench_test.go

@@ -83,7 +83,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
  return func(i int, gen *BlockGen) {
  toaddr := common.Address{}
  data := make([]byte, nbytes)
- gas, _ := IntrinsicGas(data, nil, false, false, false, false)
+ gas, _ := IntrinsicGas(data, nil, nil, false, false, false, false)
  signer := gen.Signer()
  gasPrice := big.NewInt(0)
  if gen.header.BaseFee != nil {

core/blockchain_test.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+ "bytes"
  "errors"
  "fmt"
  "math/big"
@@ -4310,3 +4311,109 @@ func TestPragueRequests(t *testing.T) {
  t.Fatalf("block %d: failed to insert into chain: %v", n, err)
  }
 }
+
+// TestEIP7702 deploys two delegation designations and calls them. It writes one
+// value to storage which is verified after.
+func TestEIP7702(t *testing.T) {
+ var (
+ config = *params.MergedTestChainConfig
+ signer = types.LatestSigner(&config)
+ engine = beacon.NewFaker()
+ key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+ key2, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
+ addr1 = crypto.PubkeyToAddress(key1.PublicKey)
+ addr2 = crypto.PubkeyToAddress(key2.PublicKey)
+ aa = common.HexToAddress("0x000000000000000000000000000000000000aaaa")
+ bb = common.HexToAddress("0x000000000000000000000000000000000000bbbb")
+ funds = new(big.Int).Mul(common.Big1, big.NewInt(params.Ether))
+ )
+ gspec := &Genesis{
+ Config: &config,
+ Alloc: types.GenesisAlloc{
+ addr1: {Balance: funds},
+ addr2: {Balance: funds},
+ // The address 0xAAAA sstores 1 into slot 2.
+ aa: {
+ Code: []byte{
+ byte(vm.PC), // [0]
+ byte(vm.DUP1), // [0,0]
+ byte(vm.DUP1), // [0,0,0]
+ byte(vm.DUP1), // [0,0,0,0]
+ byte(vm.PUSH1), 0x01, // [0,0,0,0,1] (value)
+ byte(vm.PUSH20), addr2[0], addr2[1], addr2[2], addr2[3], addr2[4], addr2[5], addr2[6], addr2[7], addr2[8], addr2[9], addr2[10], addr2[11], addr2[12], addr2[13], addr2[14], addr2[15], addr2[16], addr2[17], addr2[18], addr2[19],
+ byte(vm.GAS),
+ byte(vm.CALL),
+ byte(vm.STOP),
+ },
+ Nonce: 0,
+ Balance: big.NewInt(0),
+ },
+ // The address 0xBBBB sstores 42 into slot 42.
+ bb: {
+ Code: []byte{
+ byte(vm.PUSH1), 0x42,
+ byte(vm.DUP1),
+ byte(vm.SSTORE),
+ byte(vm.STOP),
+ },
+ Nonce: 0,
+ Balance: big.NewInt(0),
+ },
+ },
+ }
+
+ // Sign authorization tuples.
+ auth1, _ := types.SignAuth(&types.Authorization{
+ ChainID: gspec.Config.ChainID.Uint64(),
+ Address: aa,
+ Nonce: 1,
+ }, key1)
+
+ auth2, _ := types.SignAuth(&types.Authorization{
+ ChainID: 0,
+ Address: bb,
+ Nonce: 0,
+ }, key2)
+
+ _, blocks, _ := GenerateChainWithGenesis(gspec, engine, 1, func(i int, b *BlockGen) {
+ b.SetCoinbase(aa)
+ txdata := &types.SetCodeTx{
+ ChainID: gspec.Config.ChainID.Uint64(),
+ Nonce: 0,
+ To: addr1,
+ Gas: 500000,
+ GasFeeCap: uint256.MustFromBig(newGwei(5)),
+ GasTipCap: uint256.NewInt(2),
+ AuthList: []*types.Authorization{auth1, auth2},
+ }
+ tx := types.MustSignNewTx(key1, signer, txdata)
+ b.AddTx(tx)
+ })
+ chain, err := NewBlockChain(rawdb.NewMemoryDatabase(), nil, gspec, nil, engine, vm.Config{}, nil)
+ if err != nil {
+ t.Fatalf("failed to create tester chain: %v", err)
+ }
+ defer chain.Stop()
+ if n, err := chain.InsertChain(blocks); err != nil {
+ t.Fatalf("block %d: failed to insert into chain: %v", n, err)
+ }
+
+ // Verify delegation designations were deployed.
+ state, _ := chain.State()
+ code, want := state.GetCode(addr1), types.AddressToDelegation(auth1.Address)
+ if !bytes.Equal(code, want) {
+ t.Fatalf("addr1 code incorrect: got %s, want %s", common.Bytes2Hex(code), common.Bytes2Hex(want))
+ }
+ code, want = state.GetCode(addr2), types.AddressToDelegation(auth2.Address)
+ if !bytes.Equal(code, want) {
+ t.Fatalf("addr2 code incorrect: got %s, want %s", common.Bytes2Hex(code), common.Bytes2Hex(want))
+ }
+ // Verify delegation executed the correct code.
+ var (
+ fortyTwo = common.BytesToHash([]byte{0x42})
+ actual = state.GetState(addr2, fortyTwo)
+ )
+ if actual.Cmp(fortyTwo) != 0 {
+ t.Fatalf("addr2 storage wrong: expected %d, got %d", fortyTwo, actual)
+ }
+}

core/error.go

@@ -112,4 +112,11 @@ var (
 
  // ErrBlobTxCreate is returned if a blob transaction has no explicit to field.
  ErrBlobTxCreate = errors.New("blob transaction of type create")
+
+ // ErrEmptyAuthList is returned if a set code transaction has an empty auth list.
+ ErrEmptyAuthList = errors.New("set code transaction with empty auth list")
+
+ // ErrAuthSignatureVeryHigh is returned if a set code transaction has a
+ // signature with R or S larger than 2^256-1.
+ ErrAuthSignatureVeryHigh = errors.New("set code transaction has authorization with R or S value greater than 2^256 - 1")
 )

core/state/statedb.go

@@ -373,6 +373,26 @@ func (s *StateDB) GetCodeHash(addr common.Address) common.Hash {
  return common.Hash{}
 }
 
+// ResolveCode retrieves the code at addr, resolving any delegation designations
+// that may exist.
+func (s *StateDB) ResolveCode(addr common.Address) []byte {
+ stateObject := s.resolveStateObject(addr)
+ if stateObject != nil {
+ return stateObject.Code()
+ }
+ return nil
+}
+
+// ResolveCodeHash retrieves the code at addr, resolving any delegation
+// designations that may exist.
+func (s *StateDB) ResolveCodeHash(addr common.Address) common.Hash {
+ stateObject := s.resolveStateObject(addr)
+ if stateObject != nil {
+ return common.BytesToHash(stateObject.CodeHash())
+ }
+ return common.Hash{}
+}
+
 // GetState retrieves the value associated with the specific key.
 func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {
  stateObject := s.getStateObject(addr)
@@ -599,6 +619,21 @@ func (s *StateDB) getStateObject(addr common.Address) *stateObject {
  return obj
 }
 
+// resolveStateObject follows delegation designations to resolve a state object
+// given by the address, returning nil if the object is not found or was deleted
+// in this execution context.
+func (s *StateDB) resolveStateObject(addr common.Address) *stateObject {
+ obj := s.getStateObject(addr)
+ if obj == nil {
+ return nil
+ }
+ addr, ok := types.ParseDelegation(obj.Code())
+ if !ok {
+ return obj
+ }
+ return s.getStateObject(addr)
+}
+
 func (s *StateDB) setStateObject(object *stateObject) {
  s.stateObjects[object.Address()] = object
 }
@@ -1335,6 +1370,10 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d
  al.AddAddress(sender)
  if dst != nil {
  al.AddAddress(*dst)
+ // If the dst has a delegation, also warm its target.
+ if addr, ok := types.ParseDelegation(s.GetCode(*dst)); ok {
+ al.AddAddress(addr)
+ }
  // If it's a create-tx, the destination will be added inside evm.create
  }
  for _, addr := range precompiles {

core/state_processor_test.go

@@ -342,7 +342,7 @@ func TestStateProcessorErrors(t *testing.T) {
  txs: []*types.Transaction{
  mkDynamicTx(0, common.Address{}, params.TxGas-1000, big.NewInt(0), big.NewInt(0)),
  },
- want: "could not apply tx 0 [0x88626ac0d53cb65308f2416103c62bb1f18b805573d4f96a3640bbbfff13c14f]: sender not an eoa: address 0x71562b71999873DB5b286dF957af199Ec94617F7, codehash: 0x9280914443471259d4570a8661015ae4a5b80186dbc619658fb494bebc3da3d1",
+ want: "could not apply tx 0 [0x88626ac0d53cb65308f2416103c62bb1f18b805573d4f96a3640bbbfff13c14f]: sender not an eoa: address 0x71562b71999873DB5b286dF957af199Ec94617F7, len(code): 4",
  },
  } {
  block := GenerateBadBlock(gspec.ToBlock(), beacon.New(ethash.NewFaker()), tt.txs, gspec.Config)
@@ -430,12 +430,12 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr
 
 var (
  code = common.FromHex(`6060604052600a8060106000396000f360606040526008565b00`)
- intrinsicContractCreationGas, _ = IntrinsicGas(code, nil, true, true, true, true)
+ intrinsicContractCreationGas, _ = IntrinsicGas(code, nil, nil, true, true, true, true)
  // A contract creation that calls EXTCODECOPY in the constructor. Used to ensure that the witness
  // will not contain that copied data.
  // Source: https://gist.github.com/gballet/a23db1e1cb4ed105616b5920feb75985
  codeWithExtCodeCopy = common.FromHex(`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`)
- intrinsicCodeWithExtCodeCopyGas, _ = IntrinsicGas(codeWithExtCodeCopy, nil, true, true, true, true)
+ intrinsicCodeWithExtCodeCopyGas, _ = IntrinsicGas(codeWithExtCodeCopy, nil, nil, true, true, true, true)
 )
 
 func TestProcessVerkle(t *testing.T) {