FilesExpand file tree

master

/

evmaccesslist.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

94 lines (86 loc) · 2.64 KB

master

/

evmaccesslist.go

Copy path

Top

File metadata and controls

• Code
• Blame

94 lines (86 loc) · 2.64 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

package outscript

import (

"encoding/hex"

"fmt"

)

// EvmAccessTuple is a single entry of an EIP-2930 access list: an address

// together with the storage slots of that address the transaction declares it

// will access. Access lists are shared by EIP-2930, EIP-1559 and EIP-7702

// transactions.

type EvmAccessTuple struct {

Address string // "0x"-prefixed 20-byte address

StorageKeys []string // "0x"-prefixed 32-byte storage keys

}

// evmAccessTupleJson is used when encoding/decoding an EvmAccessTuple to/from

// JSON, matching the eth JSON-RPC access list representation.

type evmAccessTupleJson struct {

Address string `json:"address"`

StorageKeys []string `json:"storageKeys"`

}

// rlpTuple returns the two-element RLP representation [address, [storageKeys...]].

func (t *EvmAccessTuple) rlpTuple() []any {

keys := make([]any, len(t.StorageKeys))

for i, k := range t.StorageKeys {

keys[i] = k

}

return []any{t.Address, keys}

}

// toJson converts the access tuple into its JSON representation.

func (t *EvmAccessTuple) toJson() *evmAccessTupleJson {

keys := make([]string, len(t.StorageKeys))

copy(keys, t.StorageKeys)

return &evmAccessTupleJson{Address: t.Address, StorageKeys: keys}

}

// toAccessTuple converts the JSON representation into an EvmAccessTuple.

func (j *evmAccessTupleJson) toAccessTuple() *EvmAccessTuple {

keys := make([]string, len(j.StorageKeys))

copy(keys, j.StorageKeys)

return &EvmAccessTuple{Address: j.Address, StorageKeys: keys}

}

// accessListRlp returns the transaction's access list as an RLP list of tuples.

func (tx *EvmTx) accessListRlp() []any {

out := make([]any, len(tx.AccessList))

for i, t := range tx.AccessList {

out[i] = t.rlpTuple()

}

return out

}

// parseAccessList decodes the RLP access_list of a transaction into a slice of

// EvmAccessTuple.

func parseAccessList(v any) ([]*EvmAccessTuple, error) {

items, err := asList(v)

if err != nil {

return nil, err

}

out := make([]*EvmAccessTuple, 0, len(items))

for _, item := range items {

tuple, err := asList(item)

if err != nil {

return nil, err

}

if len(tuple) != 2 {

return nil, fmt.Errorf("access list tuple must have 2 fields, got %d", len(tuple))

}

addr, err := asBytes(tuple[0])

if err != nil {

return nil, err

}

keyList, err := asList(tuple[1])

if err != nil {

return nil, err

}

keys := make([]string, 0, len(keyList))

for _, k := range keyList {

kb, err := asBytes(k)

if err != nil {

return nil, err

}

keys = append(keys, "0x"+hex.EncodeToString(kb))

}

out = append(out, &EvmAccessTuple{

Address: "0x" + hex.EncodeToString(addr),

StorageKeys: keys,

})

}

return out, nil

}