From 589e9490c50d403aa4107bf1f7e0218dc396611f Mon Sep 17 00:00:00 2001 From: Scott Fairclough <70711990+hexoscott@users.noreply.github.com> Date: Wed, 29 Jan 2025 15:48:45 +0000 Subject: [PATCH] Inters speed up 2 (#1694) * moving from big int usage for storage key calculation * use common package to avoid big int when parsing an address * alternative scalar to array using uint64 rather than big int * remove unused util function --- core/state/trie_db.go | 8 +- smt/pkg/smt/entity_storage.go | 16 ++-- smt/pkg/smt/proof_test.go | 40 ++++++--- smt/pkg/smt/smt.go | 10 +-- smt/pkg/smt/smt_state_reader.go | 9 +- smt/pkg/utils/util_test.go | 103 +++++++++++++++++++++++ smt/pkg/utils/utils.go | 143 +++++++++++++++++--------------- turbo/jsonrpc/zkevm_api.go | 6 +- zk/stages/stage_interhashes.go | 18 ++-- 9 files changed, 241 insertions(+), 112 deletions(-) diff --git a/core/state/trie_db.go b/core/state/trie_db.go index 965562315d0..8b2247f4dbc 100644 --- a/core/state/trie_db.go +++ b/core/state/trie_db.go @@ -927,10 +927,10 @@ func (tds *TrieDbState) ResolveSMTRetainList(inclusion map[libcommon.Address][]l } getSMTPath := func(ethAddr string, key string) ([]int, error) { - a := utils.ConvertHexToBigInt(ethAddr) - addr := utils.ScalarToArrayBig(a) - - storageKey := utils.KeyContractStorage(addr, key) + storageKey, err := utils.KeyContractStorage(ethAddr, key) + if err != nil { + return nil, err + } return storageKey.GetPath(), nil } diff --git a/smt/pkg/smt/entity_storage.go b/smt/pkg/smt/entity_storage.go index f115359a0e6..bd6ae63c8fc 100644 --- a/smt/pkg/smt/entity_storage.go +++ b/smt/pkg/smt/entity_storage.go @@ -38,7 +38,7 @@ func (s *SMT) SetAccountBalance(ethAddr string, balance *big.Int) (*big.Int, err return nil, err } - ks := utils.EncodeKeySource(utils.KEY_BALANCE, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.KEY_BALANCE, common.HexToAddress(ethAddr), common.Hash{}) err = s.Db.InsertKeySource(keyBalance, ks) if err != nil { return nil, err @@ -56,7 +56,7 @@ func (s *SMT) SetAccountNonce(ethAddr string, nonce *big.Int) (*big.Int, error) return nil, err } - ks := utils.EncodeKeySource(utils.KEY_NONCE, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.KEY_NONCE, common.HexToAddress(ethAddr), common.Hash{}) err = s.Db.InsertKeySource(keyNonce, ks) if err != nil { return nil, err @@ -90,7 +90,7 @@ func (s *SMT) SetContractBytecode(ethAddr string, bytecode string) error { return err } - ks := utils.EncodeKeySource(utils.SC_CODE, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.SC_CODE, common.HexToAddress(ethAddr), common.Hash{}) err = s.Db.InsertKeySource(keyContractCode, ks) @@ -103,7 +103,7 @@ func (s *SMT) SetContractBytecode(ethAddr string, bytecode string) error { return err } - ks = utils.EncodeKeySource(utils.SC_LENGTH, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks = utils.EncodeKeySource(utils.SC_LENGTH, common.HexToAddress(ethAddr), common.Hash{}) return s.Db.InsertKeySource(keyContractLength, ks) } @@ -321,12 +321,12 @@ func (s *SMT) SetStorage(ctx context.Context, logPrefix string, accChanges map[l return nil, nil, fmt.Errorf("[%s] Context done", logPrefix) default: } - ethAddr := addr.String() - ethAddrBigInt := utils.ConvertHexToBigInt(ethAddr) - ethAddrBigIngArray := utils.ScalarToArrayBig(ethAddrBigInt) for k, v := range storage { - keyStoragePosition := utils.KeyContractStorage(ethAddrBigIngArray, k) + keyStoragePosition, err := utils.KeyContractStorage(addr.String(), k) + if err != nil { + return nil, nil, err + } valueBigInt := convertStringToBigInt(v) keysBatchStorage = append(keysBatchStorage, &keyStoragePosition) if valuesBatchStorage, isDelete, err = appendToValuesBatchStorageBigInt(valuesBatchStorage, valueBigInt); err != nil { diff --git a/smt/pkg/smt/proof_test.go b/smt/pkg/smt/proof_test.go index 0c68b3ae612..2488a3f5bb7 100644 --- a/smt/pkg/smt/proof_test.go +++ b/smt/pkg/smt/proof_test.go @@ -63,18 +63,19 @@ func TestVerifyAndGetVal(t *testing.T) { t.Fatalf("BuildProofs() error = %v", err) } - contractAddress := libcommon.HexToAddress("0x71dd1027069078091B3ca48093B00E4735B20624") - a := utils.ConvertHexToBigInt(contractAddress.String()) - address := utils.ScalarToArrayBig(a) - smtRoot, _ := smtTrie.RoSMT.DbRo.GetLastRoot() if err != nil { t.Fatalf("GetLastRoot() error = %v", err) } root := utils.ScalarToRoot(smtRoot) + address := "0x71dd1027069078091B3ca48093B00E4735B20624" + t.Run("Value exists and proof is correct", func(t *testing.T) { - storageKey := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + storageKey, err := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + if err != nil { + t.Fatalf("KeyContractStorage() error = %v", err) + } storageProof := smt.FilterProofs(proofs, storageKey) val, err := smt.VerifyAndGetVal(root, storageProof, storageKey) @@ -96,10 +97,13 @@ func TestVerifyAndGetVal(t *testing.T) { // Fuzz with 1000 non-existent keys for i := 0; i < 1000; i++ { - nonExistentKey := utils.KeyContractStorage( + nonExistentKey, err := utils.KeyContractStorage( address, libcommon.HexToHash(fmt.Sprintf("0xdeadbeefabcd1234%d", i)).String(), ) + if err != nil { + t.Fatalf("KeyContractStorage() error = %v", err) + } nonExistentKeys = append(nonExistentKeys, nonExistentKey) nonExistentKeyPath := nonExistentKey.GetPath() keyBytes := make([]byte, 0, len(nonExistentKeyPath)) @@ -132,7 +136,10 @@ func TestVerifyAndGetVal(t *testing.T) { t.Run("Value doesn't exist but non-existent proof is insufficient", func(t *testing.T) { nonExistentRl := trie.NewRetainList(0) - nonExistentKey := utils.KeyContractStorage(address, libcommon.HexToHash("0x999").String()) + nonExistentKey, err := utils.KeyContractStorage(address, libcommon.HexToHash("0x999").String()) + if err != nil { + t.Fatalf("KeyContractStorage() error = %v", err) + } nonExistentKeyPath := nonExistentKey.GetPath() keyBytes := make([]byte, 0, len(nonExistentKeyPath)) @@ -165,7 +172,10 @@ func TestVerifyAndGetVal(t *testing.T) { }) t.Run("Value exists but proof is incorrect (first value corrupted)", func(t *testing.T) { - storageKey := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + storageKey, err := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + if err != nil { + t.Fatalf("KeyContractStorage() error = %v", err) + } storageProof := smt.FilterProofs(proofs, storageKey) // Corrupt the proof by changing a byte @@ -173,7 +183,7 @@ func TestVerifyAndGetVal(t *testing.T) { storageProof[0][0] ^= 0xFF // Flip all bits in the first byte } - _, err := smt.VerifyAndGetVal(root, storageProof, storageKey) + _, err = smt.VerifyAndGetVal(root, storageProof, storageKey) if err == nil { if err == nil || !strings.Contains(err.Error(), "root mismatch at level 0") { @@ -183,7 +193,10 @@ func TestVerifyAndGetVal(t *testing.T) { }) t.Run("Value exists but proof is incorrect (last value corrupted)", func(t *testing.T) { - storageKey := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + storageKey, err := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + if err != nil { + t.Fatalf("KeyContractStorage() error = %v", err) + } storageProof := smt.FilterProofs(proofs, storageKey) // Corrupt the proof by changing the last byte of the last proof element @@ -194,7 +207,7 @@ func TestVerifyAndGetVal(t *testing.T) { } } - _, err := smt.VerifyAndGetVal(root, storageProof, storageKey) + _, err = smt.VerifyAndGetVal(root, storageProof, storageKey) if err == nil { if err == nil || !strings.Contains(err.Error(), fmt.Sprintf("root mismatch at level %d", len(storageProof)-1)) { @@ -204,7 +217,10 @@ func TestVerifyAndGetVal(t *testing.T) { }) t.Run("Value exists but proof is insufficient", func(t *testing.T) { - storageKey := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + storageKey, err := utils.KeyContractStorage(address, libcommon.HexToHash("0x5").String()) + if err != nil { + t.Fatalf("KeyContractStorage() error = %v", err) + } storageProof := smt.FilterProofs(proofs, storageKey) // Modify the proof to claim the value doesn't exist diff --git a/smt/pkg/smt/smt.go b/smt/pkg/smt/smt.go index 9a2b3b7f84b..3d40955b8d5 100644 --- a/smt/pkg/smt/smt.go +++ b/smt/pkg/smt/smt.go @@ -165,9 +165,6 @@ func (s *SMT) InsertStorage(ethAddr string, storage *map[string]string, chm *map s.clearUpMutex.Lock() defer s.clearUpMutex.Unlock() - a := utils.ConvertHexToBigInt(ethAddr) - add := utils.ScalarToArrayBig(a) - or, err := s.getLastRoot() if err != nil { return nil, err @@ -177,7 +174,10 @@ func (s *SMT) InsertStorage(ethAddr string, storage *map[string]string, chm *map NewRootScalar: &or, } for k := range *storage { - keyStoragePosition := utils.KeyContractStorage(add, k) + keyStoragePosition, err := utils.KeyContractStorage(ethAddr, k) + if err != nil { + return nil, err + } smtr, err = s.insert(keyStoragePosition, *(*chm)[k], (*vhm)[k], *smtr.NewRootScalar) if err != nil { return nil, err @@ -185,7 +185,7 @@ func (s *SMT) InsertStorage(ethAddr string, storage *map[string]string, chm *map sp, _ := utils.StrValToBigInt(k) - ks := utils.EncodeKeySource(utils.SC_STORAGE, utils.ConvertHexToAddress(ethAddr), common.BigToHash(sp)) + ks := utils.EncodeKeySource(utils.SC_STORAGE, common.HexToAddress(ethAddr), common.BigToHash(sp)) err = s.Db.InsertKeySource(keyStoragePosition, ks) if err != nil { diff --git a/smt/pkg/smt/smt_state_reader.go b/smt/pkg/smt/smt_state_reader.go index 4e1b4849497..fe57defa4a8 100644 --- a/smt/pkg/smt/smt_state_reader.go +++ b/smt/pkg/smt/smt_state_reader.go @@ -135,14 +135,15 @@ func (s *SMT) GetAccountCodeHash(address libcommon.Address) (libcommon.Hash, err // getValue returns the value of a key from SMT by traversing the SMT func (s *SMT) getValue(key int, address libcommon.Address, storageKey *libcommon.Hash) ([]byte, error) { var kn utils.NodeKey + var err error if storageKey == nil { kn = utils.Key(address.String(), key) } else { - a := utils.ConvertHexToBigInt(address.String()) - add := utils.ScalarToArrayBig(a) - - kn = utils.KeyContractStorage(add, storageKey.String()) + kn, err = utils.KeyContractStorage(address.String(), storageKey.String()) + if err != nil { + return nil, err + } } return s.getValueInBytes(kn) diff --git a/smt/pkg/utils/util_test.go b/smt/pkg/utils/util_test.go index 622c5e6f799..5979f194242 100644 --- a/smt/pkg/utils/util_test.go +++ b/smt/pkg/utils/util_test.go @@ -162,6 +162,31 @@ func TestScalarToArrayBig(t *testing.T) { } } +func TestScalarToArrayUint64(t *testing.T) { + scalar := big.NewInt(0x1234567890ABCDEF) + + expected := [8]uint64{ + 0x90ABCDEF, + 0x12345678, + 0, + 0, + 0, + 0, + 0, + 0, + } + + result, err := ScalarToArrayUint64(scalar) + + if err != nil { + t.Errorf("ScalarToArray = %v; want %v", result, expected) + } + + if !reflect.DeepEqual(result, expected) { + t.Errorf("ScalarToArray = %v; want %v", result, expected) + } +} + func BenchmarkScalarToArrayBig(b *testing.B) { scalar := big.NewInt(0x1234567890ABCDEF) for i := 0; i < b.N; i++ { @@ -771,3 +796,81 @@ func TestNodeKeyFromPath(t *testing.T) { } } } + +func Test_Key(t *testing.T) { + tests := []struct { + input string + output NodeKey + }{ + { + input: "0xe859276098f208D003ca6904C6cC26629Ee364Ce", + output: NodeKey{ + 9755015262748197613, + 11140630475045976694, + 14930209430661078379, + 6319951756608990063, + }, + }, + } + + for _, test := range tests { + result := Key(test.input, 1) + if result != test.output { + t.Errorf("expected %v but got %v", test.output, result) + } + } +} + +func TestKeyContractStorage(t *testing.T) { + tests := []struct { + input string + output NodeKey + }{ + { + input: "0xe859276098f208D003ca6904C6cC26629Ee364Ce", + output: NodeKey{ + 9485388526025222793, + 2844922146222416636, + 12800508867551015356, + 9480521524011931274, + }, + }, + } + + for _, test := range tests { + result, err := KeyContractStorage(test.input, "0x1") + if err != nil { + t.Fatal(err) + } + if result != test.output { + t.Errorf("expected %v but got %v", test.output, result) + } + } +} + +func TestKeyBig(t *testing.T) { + tests := []struct { + input *big.Int + output NodeKey + }{ + { + input: big.NewInt(1092034958475866), + output: NodeKey{ + 11593000745318970063, + 7942385326937081179, + 13970824778267919554, + 7405798476109204467, + }, + }, + } + + for _, test := range tests { + result, err := KeyBig(test.input, 1) + if err != nil { + t.Fatal(err) + } + if *result != test.output { + t.Errorf("expected %v but got %v", test.output, result) + } + } +} diff --git a/smt/pkg/utils/utils.go b/smt/pkg/utils/utils.go index e8e3e9ceb49..eff7c5b9472 100644 --- a/smt/pkg/utils/utils.go +++ b/smt/pkg/utils/utils.go @@ -16,15 +16,27 @@ import ( "golang.org/x/exp/slices" ) +func init() { + const hashPoseidonAllZeroes = "0xc71603f33a1144ca7953db0ab48808f4c4055e3364a246c33c18a9786cb0b359" + var err error + PoseidonAllZeroesHash, err = StringToH4(hashPoseidonAllZeroes) + if err != nil { + panic(err) + } +} + const ( - KEY_BALANCE = 0 - KEY_NONCE = 1 - SC_CODE = 2 - SC_STORAGE = 3 - SC_LENGTH = 4 - HASH_POSEIDON_ALL_ZEROES = "0xc71603f33a1144ca7953db0ab48808f4c4055e3364a246c33c18a9786cb0b359" - BYTECODE_ELEMENTS_HASH = 8 - BYTECODE_BYTES_ELEMENT = 7 + KEY_BALANCE = 0 + KEY_NONCE = 1 + SC_CODE = 2 + SC_STORAGE = 3 + SC_LENGTH = 4 + BYTECODE_ELEMENTS_HASH = 8 + BYTECODE_BYTES_ELEMENT = 7 +) + +var ( + PoseidonAllZeroesHash [4]uint64 ) type NodeValue8 [8]*big.Int @@ -294,9 +306,39 @@ func ConvertHexToBigInt(hex string) *big.Int { return n } -func ConvertHexToAddress(hex string) common.Address { - bigInt := ConvertHexToBigInt(hex) - return common.BigToAddress(bigInt) +// ConvertHexToUint64s converts a hex string into an array of uint64s - designed to offer the same functionality +// as working with big ints but without the allocation headache +func ConvertHexToUint64Array(hexStr string) ([8]uint64, error) { + // Remove 0x prefix if present + hexStr = strings.TrimPrefix(hexStr, "0x") + + if len(hexStr)%2 != 0 { + hexStr = "0" + hexStr // Pad with leading zero if odd length + } + + // Convert hex string to bytes + bytes, err := hex.DecodeString(hexStr) + if err != nil { + return [8]uint64{}, fmt.Errorf("invalid hex string: %v", err) + } + + // Pad to 32 bytes (256 bits) + paddedBytes := make([]byte, 32) + copy(paddedBytes[len(paddedBytes)-len(bytes):], bytes) // Right-align the bytes + + // Convert to uint64s, taking 32 bits at a time + result := [8]uint64{ + uint64(binary.BigEndian.Uint32(paddedBytes[28:32])), // r0: lowest 32 bits + uint64(binary.BigEndian.Uint32(paddedBytes[24:28])), // r1: bits 32-63 + uint64(binary.BigEndian.Uint32(paddedBytes[20:24])), // r2: bits 64-95 + uint64(binary.BigEndian.Uint32(paddedBytes[16:20])), // r3: bits 96-127 + uint64(binary.BigEndian.Uint32(paddedBytes[12:16])), // r4: bits 128-159 + uint64(binary.BigEndian.Uint32(paddedBytes[8:12])), // r5: bits 160-191 + uint64(binary.BigEndian.Uint32(paddedBytes[4:8])), // r6: bits 192-223 + uint64(binary.BigEndian.Uint32(paddedBytes[0:4])), // r7: bits 224-255 + } + + return result, nil } func ArrayToScalar(array []uint64) *big.Int { @@ -481,49 +523,6 @@ func RemoveKeyBits(k NodeKey, nBits int) NodeKey { return auxk } -func ScalarToArrayBig12(scalar *big.Int) []*big.Int { - scalar = new(big.Int).Set(scalar) - mask := new(big.Int) - mask.SetString("FFFFFFFF", 16) - - r0 := new(big.Int).And(scalar, mask) - - r1 := new(big.Int).Rsh(scalar, 32) - r1 = new(big.Int).And(r1, mask) - - r2 := new(big.Int).Rsh(scalar, 64) - r2 = new(big.Int).And(r2, mask) - - r3 := new(big.Int).Rsh(scalar, 96) - r3 = new(big.Int).And(r3, mask) - - r4 := new(big.Int).Rsh(scalar, 128) - r4 = new(big.Int).And(r4, mask) - - r5 := new(big.Int).Rsh(scalar, 160) - r5 = new(big.Int).And(r5, mask) - - r6 := new(big.Int).Rsh(scalar, 192) - r6 = new(big.Int).And(r6, mask) - - r7 := new(big.Int).Rsh(scalar, 224) - r7 = new(big.Int).And(r7, mask) - - r8 := new(big.Int).Rsh(scalar, 256) - r8 = new(big.Int).And(r8, mask) - - r9 := new(big.Int).Rsh(scalar, 288) - r9 = new(big.Int).And(r9, mask) - - r10 := new(big.Int).Rsh(scalar, 320) - r10 = new(big.Int).And(r10, mask) - - r11 := new(big.Int).Rsh(scalar, 352) - r11 = new(big.Int).And(r11, mask) - - return []*big.Int{r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11} -} - var mask = big.NewInt(4294967295) func ScalarToArrayBig(scalar *big.Int) []*big.Int { @@ -553,6 +552,10 @@ func ScalarToArrayBig(scalar *big.Int) []*big.Int { return []*big.Int{r0, r1, r2, r3, r4, r5, r6, r7} } +func ScalarToArrayUint64(scalar *big.Int) ([8]uint64, error) { + return ConvertHexToUint64Array(scalar.Text(16)) +} + func ArrayBigToScalar(arr []*big.Int) *big.Int { scalar := new(big.Int) for i := len(arr) - 1; i >= 0; i-- { @@ -628,31 +631,30 @@ func KeyContractLength(ethAddr string) NodeKey { } func Key(ethAddr string, c int) NodeKey { - a := ConvertHexToBigInt(ethAddr) - add := ScalarToArrayBig(a) - - key1 := NodeValue8{add[0], add[1], add[2], add[3], add[4], add[5], big.NewInt(int64(c)), big.NewInt(0)} - key1Capacity, err := StringToH4(HASH_POSEIDON_ALL_ZEROES) + addressArray, err := ConvertHexToUint64Array(ethAddr) if err != nil { return NodeKey{} } - return Hash(key1.ToUintArray(), key1Capacity) + key := [8]uint64{addressArray[0], addressArray[1], addressArray[2], addressArray[3], addressArray[4], addressArray[5], uint64(c), 0} + + return Hash(key, PoseidonAllZeroesHash) } func KeyBig(k *big.Int, c int) (*NodeKey, error) { if k == nil { return nil, errors.New("nil key") } - add := ScalarToArrayBig(k) - key1 := NodeValue8{add[0], add[1], add[2], add[3], add[4], add[5], big.NewInt(int64(c)), big.NewInt(0)} - key1Capacity, err := StringToH4(HASH_POSEIDON_ALL_ZEROES) + add, err := ScalarToArrayUint64(k) if err != nil { return nil, err } - hk0 := Hash(key1.ToUintArray(), key1Capacity) + key1 := [8]uint64{add[0], add[1], add[2], add[3], add[4], add[5], uint64(c), 0} + + hk0 := Hash(key1, PoseidonAllZeroesHash) + return &NodeKey{hk0[0], hk0[1], hk0[2], hk0[3]}, nil } @@ -664,18 +666,23 @@ func StrValToBigInt(v string) (*big.Int, bool) { return new(big.Int).SetString(v, 10) } -func KeyContractStorage(ethAddr []*big.Int, storagePosition string) NodeKey { +func KeyContractStorage(ethAddr string, storagePosition string) (NodeKey, error) { sp, _ := StrValToBigInt(storagePosition) spArray, err := NodeValue8FromBigIntArray(ScalarToArrayBig(sp)) if err != nil { - return NodeKey{} + return NodeKey{}, err } hk0 := Hash(spArray.ToUintArray(), [4]uint64{0, 0, 0, 0}) - key1 := NodeValue8{ethAddr[0], ethAddr[1], ethAddr[2], ethAddr[3], ethAddr[4], ethAddr[5], big.NewInt(int64(SC_STORAGE)), big.NewInt(0)} + addrArray, err := ConvertHexToUint64Array(ethAddr) + if err != nil { + return NodeKey{}, err + } + + key := [8]uint64{addrArray[0], addrArray[1], addrArray[2], addrArray[3], addrArray[4], addrArray[5], uint64(SC_STORAGE), 0} - return Hash(key1.ToUintArray(), hk0) + return Hash(key, hk0), nil } func HashContractBytecode(bc string) string { diff --git a/turbo/jsonrpc/zkevm_api.go b/turbo/jsonrpc/zkevm_api.go index 8229cf996bb..cd726a8c301 100644 --- a/turbo/jsonrpc/zkevm_api.go +++ b/turbo/jsonrpc/zkevm_api.go @@ -1747,9 +1747,11 @@ func (zkapi *ZkEvmAPIImpl) GetProof(ctx context.Context, address common.Address, StorageProof: make([]accounts.SMTStorageProofResult, 0), } - addressArrayBig := smtUtils.ScalarToArrayBig(smtUtils.ConvertHexToBigInt(address.String())) for _, k := range storageKeys { - storageKey := smtUtils.KeyContractStorage(addressArrayBig, k.String()) + storageKey, err := smtUtils.KeyContractStorage(address.String(), k.String()) + if err != nil { + return nil, fmt.Errorf("key contract storage failed: %w", err) + } storageProofs := smt.FilterProofs(proofs, storageKey) valueBytes, err := smt.VerifyAndGetVal(stateRootNode, storageProofs, storageKey) diff --git a/zk/stages/stage_interhashes.go b/zk/stages/stage_interhashes.go index 8149cb1554e..8ff33ccdaf4 100644 --- a/zk/stages/stage_interhashes.go +++ b/zk/stages/stage_interhashes.go @@ -517,7 +517,7 @@ func insertContractBytecodeToKV(db smt.DB, keys []utils.NodeKey, ethAddr string, keys = append(keys, keyContractCode) db.CollectAccountValue(keyContractCode, *valueContractCode) - ks := utils.EncodeKeySource(utils.SC_CODE, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.SC_CODE, common.HexToAddress(ethAddr), common.Hash{}) db.CollectKeySource(keyContractCode, ks) } @@ -525,7 +525,7 @@ func insertContractBytecodeToKV(db smt.DB, keys []utils.NodeKey, ethAddr string, keys = append(keys, keyContractLength) db.CollectAccountValue(keyContractLength, *valueContractLength) - ks := utils.EncodeKeySource(utils.SC_LENGTH, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.SC_LENGTH, common.HexToAddress(ethAddr), common.Hash{}) db.CollectKeySource(keyContractLength, ks) } @@ -533,15 +533,15 @@ func insertContractBytecodeToKV(db smt.DB, keys []utils.NodeKey, ethAddr string, } func insertContractStorageToKV(db smt.DB, keys []utils.NodeKey, ethAddr string, storage map[string]string) ([]utils.NodeKey, error) { - a := utils.ConvertHexToBigInt(ethAddr) - add := utils.ScalarToArrayBig(a) - for k, v := range storage { if v == "" { continue } - keyStoragePosition := utils.KeyContractStorage(add, k) + keyStoragePosition, err := utils.KeyContractStorage(ethAddr, k) + if err != nil { + return []utils.NodeKey{}, err + } base := 10 if strings.HasPrefix(v, "0x") { @@ -562,7 +562,7 @@ func insertContractStorageToKV(db smt.DB, keys []utils.NodeKey, ethAddr string, sp, _ := utils.StrValToBigInt(k) - ks := utils.EncodeKeySource(utils.SC_STORAGE, utils.ConvertHexToAddress(ethAddr), common.BigToHash(sp)) + ks := utils.EncodeKeySource(utils.SC_STORAGE, common.HexToAddress(ethAddr), common.BigToHash(sp)) db.CollectKeySource(keyStoragePosition, ks) } } @@ -590,14 +590,14 @@ func insertAccountStateToKV(db smt.DB, keys []utils.NodeKey, ethAddr string, bal keys = append(keys, keyBalance) db.CollectAccountValue(keyBalance, *valueBalance) - ks := utils.EncodeKeySource(utils.KEY_BALANCE, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.KEY_BALANCE, common.HexToAddress(ethAddr), common.Hash{}) db.CollectKeySource(keyBalance, ks) } if !valueNonce.IsZero() { keys = append(keys, keyNonce) db.CollectAccountValue(keyNonce, *valueNonce) - ks := utils.EncodeKeySource(utils.KEY_NONCE, utils.ConvertHexToAddress(ethAddr), common.Hash{}) + ks := utils.EncodeKeySource(utils.KEY_NONCE, common.HexToAddress(ethAddr), common.Hash{}) db.CollectKeySource(keyNonce, ks) } return keys, nil