Added a new RPC endpoint (bor_sendRawTransactionConditional) to support EIP-4337 Bundled Transactions

core/state/intra_block_state.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ledgerwatch/erigon-lib/chain"
 	libcommon "github.com/ledgerwatch/erigon-lib/common"
 	types2 "github.com/ledgerwatch/erigon-lib/types"
+	"github.com/ledgerwatch/erigon/common"
 	"github.com/ledgerwatch/erigon/common/u256"
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/core/types/accounts"
@@ -827,3 +828,46 @@ func (sdb *IntraBlockState) AddressInAccessList(addr libcommon.Address) bool {
 func (sdb *IntraBlockState) SlotInAccessList(addr libcommon.Address, slot libcommon.Hash) (addressPresent bool, slotPresent bool) {
 	return sdb.accessList.Contains(addr, slot)
 }
+
+// ValidateKnownAccounts validates the knownAccounts passed in the options parameter in the conditional transaction (EIP-4337)
+func (sdb *IntraBlockState) ValidateKnownAccounts(knownAccounts types2.KnownAccountStorageConditions) error {
+	if knownAccounts == nil {
+		return nil
+	}
+
+	for address, condition := range knownAccounts {
+		tempAccount, err := sdb.stateReader.ReadAccountData(address)
+		if err != nil {
+			return fmt.Errorf("error reading account data at: %v", address)
+		}
+
+		if tempAccount == nil {
+			return fmt.Errorf("Storage Trie is nil for: %v", address)
+		}
+
+		// check if the value is hex string or an object
+		switch {
+		case condition.IsSingle():
+			if *condition.StorageRootHash != tempAccount.Root {
+				return fmt.Errorf("invalid root hash for: %v root hash: %v actual root hash: %v", address, condition.StorageRootHash, tempAccount.Root)
+			}
+		case condition.IsStorage():
+			for slot, value := range condition.StorageSlotHashes {
+				slot := slot
+				tempByte, err := sdb.stateReader.ReadAccountStorage(address, tempAccount.Incarnation, &slot)
+				if err != nil {
+					return fmt.Errorf("error reading account storage at: %v slot: %v", address, slot)
+				}
+
+				actualValue := libcommon.BytesToHash(common.LeftPadBytes(tempByte, 32))
+				if value != actualValue {
+					return fmt.Errorf("invalid slot value at address: %v slot: %v value: %v actual value: %v", address, slot, value, actualValue)
+				}
+			}
+		default:
+			return fmt.Errorf("impossible to validate known accounts: %v", address)
+		}
+	}
+
+	return nil
+}

core/state/intra_block_state_test.go

@@ -34,7 +34,9 @@ import (
 	"github.com/holiman/uint256"
 	libcommon "github.com/ledgerwatch/erigon-lib/common"
 	"github.com/ledgerwatch/erigon-lib/kv/memdb"
+	types2 "github.com/ledgerwatch/erigon-lib/types"
 	"github.com/ledgerwatch/erigon/core/types"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSnapshotRandom(t *testing.T) {
@@ -348,3 +350,75 @@ func TestTransientStorage(t *testing.T) {
 		t.Fatalf("transient storage mismatch: have %x, want %x", got, exp)
 	}
 }
+
+func insertKnownAccounts[T libcommon.Hash | map[libcommon.Hash]libcommon.Hash](accounts KnownAccountStorageConditions, k libcommon.Address, v T) {
+	switch typedV := any(v).(type) {
+	case libcommon.Hash:
+		accounts[k] = &KnownAccountStorageCondition{StorageRootHash: &typedV}
+	case map[libcommon.Hash]libcommon.Hash:
+		accounts[k] = &KnownAccountStorageCondition{StorageSlotHashes: typedV}
+	}
+}
+
+func TestValidateKnownAccounts(t *testing.T) {
+	t.Parallel()
+
+	knownAccounts := make(types2.KnownAccountStorageConditions)
+
+	insertKnownAccounts(knownAccounts, libcommon.HexToAddress("0xadd1add1add1add1add1add1add1add1add1add1"), libcommon.HexToHash("0x2d6f8a898e7dec0bb7a50e8c142be32d7c98c096ff68ed57b9b08280d9aca1ce"))
+	insertKnownAccounts(knownAccounts, libcommon.HexToAddress("0xadd2add2add2add2add2add2add2add2add2add2"), map[libcommon.Hash]libcommon.Hash{
+		libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000aaa"): libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000bbb"),
+		libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ccc"): libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ddd"),
+	})
+
+	stateobjaddr1 := libcommon.HexToAddress("0xadd1add1add1add1add1add1add1add1add1add1")
+	stateobjaddr2 := libcommon.HexToAddress("0xadd2add2add2add2add2add2add2add2add2add2")
+
+	storageaddr1 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000zzz")
+	storageaddr21 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000aaa")
+	storageaddr22 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ccc")
+
+	data1 := libcommon.BytesToHash([]byte{24})
+	data21 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000bbb")
+	data22 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ddd")
+
+	s := newStateTest()
+
+	// set initial state object value
+	s.state.SetState(stateobjaddr1, storageaddr1, data1)
+	s.state.SetState(stateobjaddr2, storageaddr21, data21)
+	s.state.SetState(stateobjaddr2, storageaddr22, data22)
+
+	require.NoError(t, s.state.ValidateKnownAccounts(knownAccounts))
+
+	insertKnownAccounts(knownAccounts, libcommon.HexToAddress("0xadd1add1add1add1add1add1add1add1add1add2"), libcommon.HexToHash("0x2d6f8a898e7dec0bb7a50e8c142be32d7c98c096ff68ed57b9b08280d9aca1cf"))
+
+	stateobjaddr3 := libcommon.HexToAddress("0xadd1add1add1add1add1add1add1add1add1add2")
+	storageaddr3 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000yyy")
+	data3 := libcommon.BytesToHash([]byte{24})
+
+	s.state.SetState(stateobjaddr3, storageaddr3, data3)
+
+	// expected error
+	err := s.state.ValidateKnownAccounts(knownAccounts)
+	require.Error(t, err, "should have been an error")
+
+	// correct the previous mistake "0x2d6f8a898e7dec0bb7a50e8c142be32d7c98c096ff68ed57b9b08280d9aca1cf" -> "0x2d6f8a898e7dec0bb7a50e8c142be32d7c98c096ff68ed57b9b08280d9aca1ce"
+	insertKnownAccounts(knownAccounts, libcommon.HexToAddress("0xadd1add1add1add1add1add1add1add1add1add2"), libcommon.HexToHash("0x2d6f8a898e7dec0bb7a50e8c142be32d7c98c096ff68ed57b9b08280d9aca1ce"))
+	insertKnownAccounts(knownAccounts, libcommon.HexToAddress("0xadd2add2add2add2add2add2add2add2add2add3"), map[libcommon.Hash]libcommon.Hash{
+		libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000aaa"): libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000bbb"),
+		libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ccc"): libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ddd"),
+	})
+
+	stateobjaddr4 := libcommon.HexToAddress("0xadd2add2add2add2add2add2add2add2add2add3")
+	storageaddr41 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000aaa")
+	storageaddr42 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000ccc")
+	data4 := libcommon.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000bbb")
+
+	s.state.SetState(stateobjaddr4, storageaddr41, data4)
+	s.state.SetState(stateobjaddr4, storageaddr42, data4)
+
+	// expected error
+	err = s.state.ValidateKnownAccounts(knownAccounts)
+	require.Error(t, err, "should have been an error")
+}

core/types/block_test.go

@@ -512,3 +512,167 @@ func TestCopyTxs(t *testing.T) {
 	copies := CopyTxs(txs)
 	assert.Equal(t, txs, copies)
 }
+
+func TestValidateBlockNumberOptions4337(t *testing.T) {
+	t.Parallel()
+
+	testsPass := []struct {
+		number         string
+		header         Header
+		minBlockNumber *big.Int
+		maxBlockNumber *big.Int
+	}{
+		{
+			"1",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(0),
+			big.NewInt(20),
+		},
+		{
+			"2",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(10),
+			big.NewInt(10),
+		},
+		{
+			"3",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(10),
+			big.NewInt(11),
+		},
+		{
+			"4",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(0),
+			big.NewInt(10),
+		},
+	}
+
+	testsFail := []struct {
+		number         string
+		header         Header
+		minBlockNumber *big.Int
+		maxBlockNumber *big.Int
+	}{
+		{
+			"5",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(0),
+			big.NewInt(0),
+		},
+		{
+			"6",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(0),
+			big.NewInt(9),
+		},
+		{
+			"7",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(11),
+			big.NewInt(9),
+		},
+		{
+			"8",
+			Header{Number: big.NewInt(10)},
+			big.NewInt(11),
+			big.NewInt(20),
+		},
+	}
+
+	for _, test := range testsPass {
+		if _, err := types2.BigIntIsWithinRange(test.header.Number, test.minBlockNumber, test.maxBlockNumber); err != nil {
+			t.Fatalf("test number %v should not have failed. err: %v", test.number, err)
+		}
+	}
+
+	for _, test := range testsFail {
+		if _, err := types2.BigIntIsWithinRange(test.header.Number, test.minBlockNumber, test.maxBlockNumber); err == nil {
+			t.Fatalf("test number %v should have failed. err is nil", test.number)
+		}
+	}
+}
+
+func TestValidateTimestampOptions4337(t *testing.T) {
+	t.Parallel()
+
+	u64Ptr := func(n uint64) *uint64 {
+		return &n
+	}
+
+	testsPass := []struct {
+		number       string
+		header       Header
+		minTimestamp *uint64
+		maxTimestamp *uint64
+	}{
+		{
+			"1",
+			Header{Time: 1600000000},
+			u64Ptr(1500000000),
+			u64Ptr(1700000000),
+		},
+		{
+			"2",
+			Header{Time: 1600000000},
+			u64Ptr(1600000000),
+			u64Ptr(1600000000),
+		},
+		{
+			"3",
+			Header{Time: 1600000000},
+			u64Ptr(1600000000),
+			u64Ptr(1700000000),
+		},
+		{
+			"4",
+			Header{Time: 1600000000},
+			u64Ptr(1500000000),
+			u64Ptr(1600000000),
+		},
+	}
+
+	testsFail := []struct {
+		number       string
+		header       Header
+		minTimestamp *uint64
+		maxTimestamp *uint64
+	}{
+		{
+			"5",
+			Header{Time: 1600000000},
+			u64Ptr(1500000000),
+			u64Ptr(1500000000),
+		},
+		{
+			"6",
+			Header{Time: 1600000000},
+			u64Ptr(1400000000),
+			u64Ptr(1500000000),
+		},
+		{
+			"7",
+			Header{Time: 1600000000},
+			u64Ptr(1700000000),
+			u64Ptr(1500000000),
+		},
+		{
+			"8",
+			Header{Time: 1600000000},
+			u64Ptr(1700000000),
+			u64Ptr(1800000000),
+		},
+	}
+
+	for _, test := range testsPass {
+		if _, err := types2.Uint64IsWithinRange(&test.header.Time, test.minTimestamp, test.maxTimestamp); err != nil {
+			t.Fatalf("test number %v should not have failed. err: %v", test.number, err)
+		}
+	}
+
+	for _, test := range testsFail {
+		if _, err := types2.Uint64IsWithinRange(&test.header.Time, test.minTimestamp, test.maxTimestamp); err == nil {
+			t.Fatalf("test number %v should have failed. err is nil", test.number)
+		}
+	}
+}

erigon-lib/common/hash.go

@@ -61,6 +61,12 @@ func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) }
 // If b is larger than len(h), b will be cropped from the left.
 func HexToHash(s string) Hash { return BytesToHash(hexutility.FromHex(s)) }
 
+func HexToRefHash(s string) *Hash {
+	v := BytesToHash(FromHex(s))
+
+	return &v
+}
+
 // Bytes gets the byte representation of the underlying hash.
 func (h Hash) Bytes() []byte { return h[:] }