diff --git a/sync/snap_server.go b/p2p/snap_server.go similarity index 68% rename from sync/snap_server.go rename to p2p/snap_server.go index fa86e9d5a0..1810489cb8 100644 --- a/sync/snap_server.go +++ b/p2p/snap_server.go @@ -1,7 +1,7 @@ -package sync +package p2p import ( - "context" + "google.golang.org/protobuf/proto" "math/big" "github.com/NethermindEth/juno/adapters/core2p2p" @@ -43,11 +43,12 @@ type ClassRangeStreamingResult struct { RangeProof *spec.PatriciaRangeProof } +// TODO: delete, duplicate of SnapProvider type SnapServer interface { - GetContractRange(ctx context.Context, request *spec.ContractRangeRequest) (iter.Seq[*ContractRangeStreamingResult], error) - GetStorageRange(ctx context.Context, request *StorageRangeRequest) (iter.Seq[*StorageRangeStreamingResult], error) - GetClassRange(ctx context.Context, request *spec.ClassRangeRequest) (iter.Seq[*ClassRangeStreamingResult], error) - GetClasses(ctx context.Context, classHashes []*felt.Felt) ([]*spec.Class, error) + GetClassRange(request *spec.ClassRangeRequest) (iter.Seq[proto.Message], error) + GetContractRange(request *spec.ContractRangeRequest) (iter.Seq[proto.Message], error) + GetStorageRange(request *spec.ContractStorageRequest) (iter.Seq[proto.Message], error) + GetClasses(request *spec.ClassHashesRequest) (iter.Seq[proto.Message], error) } type SnapServerBlockchain interface { @@ -55,6 +56,8 @@ type SnapServerBlockchain interface { GetClasses(felts []*felt.Felt) ([]core.Class, error) } +type yieldFunc = func(proto.Message) bool + var _ SnapServerBlockchain = (*blockchain.Blockchain)(nil) func NewSnapServer(blockchain SnapServerBlockchain) SnapServer { @@ -67,7 +70,7 @@ type snapServer struct { blockchain SnapServerBlockchain } -func determineMaxNodes(specifiedMaxNodes uint64) uint64 { +func determineMaxNodes(specifiedMaxNodes uint32) uint32 { const ( defaultMaxNodes = 1024 * 16 maxNodePerRequest = 1024 * 1024 // I just want it to process faster @@ -84,8 +87,12 @@ func determineMaxNodes(specifiedMaxNodes uint64) uint64 { return maxNodePerRequest } -func (b *snapServer) GetClassRange(ctx context.Context, request *spec.ClassRangeRequest) (iter.Seq[*ClassRangeStreamingResult], error) { - return func(yield func(*ClassRangeStreamingResult) bool) { +func (b *snapServer) GetClassRange(request *spec.ClassRangeRequest) (iter.Seq[proto.Message], error) { + var finMsg proto.Message = &spec.ClassRangeResponse{ + Responses: &spec.ClassRangeResponse_Fin{}, + } + + return func(yield yieldFunc) { stateRoot := p2p2core.AdaptHash(request.Root) s, err := b.blockchain.GetStateForStateRoot(stateRoot) @@ -119,7 +126,7 @@ func (b *snapServer) GetClassRange(ctx context.Context, request *spec.ClassRange } classkeys := []*felt.Felt{} - proofs, finished, err := iterateWithLimit(ctrie, startAddr, limitAddr, determineMaxNodes(uint64(request.ChunksPerProof)), + proofs, finished, err := iterateWithLimit(ctrie, startAddr, limitAddr, determineMaxNodes(request.ChunksPerProof), func(key, value *felt.Felt) error { classkeys = append(classkeys, key) return nil @@ -143,26 +150,32 @@ func (b *snapServer) GetClassRange(ctx context.Context, request *spec.ClassRange response.Classes = append(response.Classes, core2p2p.AdaptClass(coreclass)) } - shouldContinue := yield(&ClassRangeStreamingResult{ - ContractsRoot: contractRoot, - ClassesRoot: classRoot, - Range: response, - RangeProof: Core2P2pProof(proofs), - }) + clsMsg := &spec.ClassRangeResponse{ + ContractsRoot: core2p2p.AdaptHash(contractRoot), + ClassesRoot: core2p2p.AdaptHash(classRoot), + Responses: &spec.ClassRangeResponse_Classes{ + Classes: response, + }, + RangeProof: Core2P2pProof(proofs), + } + shouldContinue := yield(clsMsg) if finished || !shouldContinue { break } startAddr = classkeys[len(classkeys)-1] } + + yield(finMsg) }, nil } -func (b *snapServer) GetContractRange( - ctx context.Context, - request *spec.ContractRangeRequest, -) (iter.Seq[*ContractRangeStreamingResult], error) { - return func(yield func(*ContractRangeStreamingResult) bool) { +func (b *snapServer) GetContractRange(request *spec.ContractRangeRequest) (iter.Seq[proto.Message], error) { + var finMsg proto.Message = &spec.ContractRangeResponse{ + Responses: &spec.ContractRangeResponse_Fin{}, + } + + return func(yield yieldFunc) { stateRoot := p2p2core.AdaptHash(request.StateRoot) s, err := b.blockchain.GetStateForStateRoot(stateRoot) @@ -189,7 +202,7 @@ func (b *snapServer) GetContractRange( states := []*spec.ContractState{} for { - proofs, finished, err := iterateWithLimit(strie, startAddr, limitAddr, determineMaxNodes(uint64(request.ChunksPerProof)), + proofs, finished, err := iterateWithLimit(strie, startAddr, limitAddr, determineMaxNodes(request.ChunksPerProof), func(key, value *felt.Felt) error { classHash, err := s.ContractClassHash(key) if err != nil { @@ -225,23 +238,35 @@ func (b *snapServer) GetContractRange( return } - shouldContinue := yield(&ContractRangeStreamingResult{ - ContractsRoot: contractRoot, - ClassesRoot: classRoot, - Range: states, + cntrMsg := &spec.ContractRangeResponse{ + Root: request.StateRoot, + ContractsRoot: core2p2p.AdaptHash(contractRoot), + ClassesRoot: core2p2p.AdaptHash(classRoot), RangeProof: Core2P2pProof(proofs), - }) + Responses: &spec.ContractRangeResponse_Range{ + Range: &spec.ContractRange{ + State: states, + }, + }, + } + shouldContinue := yield(cntrMsg) if finished || !shouldContinue { break } } + + yield(finMsg) }, nil } -func (b *snapServer) GetStorageRange(ctx context.Context, request *StorageRangeRequest) (iter.Seq[*StorageRangeStreamingResult], error) { - return func(yield func(*StorageRangeStreamingResult) bool) { - stateRoot := request.StateRoot +func (b *snapServer) GetStorageRange(request *spec.ContractStorageRequest) (iter.Seq[proto.Message], error) { + var finMsg proto.Message = &spec.ContractStorageResponse{ + Responses: &spec.ContractStorageResponse_Fin{}, + } + + return func(yield yieldFunc) { + stateRoot := p2p2core.AdaptHash(request.StateRoot) s, err := b.blockchain.GetStateForStateRoot(stateRoot) if err != nil { @@ -249,20 +274,10 @@ func (b *snapServer) GetStorageRange(ctx context.Context, request *StorageRangeR return } - contractRoot, classRoot, err := s.StateAndClassRoot() - if err != nil { - log.Error("error getting state and class root", "err", err) - return - } + var curNodeLimit uint32 = 1000000 - var curNodeLimit int64 = 1000000 - - for _, query := range request.Queries { - if ctxerr := ctx.Err(); ctxerr != nil { - break - } - - contractLimit := uint64(curNodeLimit) + for _, query := range request.Query { + contractLimit := curNodeLimit strie, err := s.StorageTrieForAddr(p2p2core.AdaptAddress(query.Address)) if err != nil { @@ -270,16 +285,24 @@ func (b *snapServer) GetStorageRange(ctx context.Context, request *StorageRangeR return } - handled, err := b.handleStorageRangeRequest(ctx, strie, query, request.ChunkPerProof, contractLimit, - func(values []*spec.ContractStoredValue, proofs []trie.ProofNode) { - yield(&StorageRangeStreamingResult{ - ContractsRoot: contractRoot, - ClassesRoot: classRoot, - StorageAddr: p2p2core.AdaptAddress(query.Address), - Range: values, - RangeProof: Core2P2pProof(proofs), - }) + handled, err := b.handleStorageRangeRequest(strie, query, request.ChunksPerProof, contractLimit, + func(values []*spec.ContractStoredValue, proofs []trie.ProofNode) bool { + stoMsg := &spec.ContractStorageResponse{ + StateRoot: request.StateRoot, + ContractAddress: query.Address, + RangeProof: Core2P2pProof(proofs), + Responses: &spec.ContractStorageResponse_Storage{ + Storage: &spec.ContractStorage{ + KeyValue: values, + }, + }, + } + if !yield(stoMsg) { + return false + } + return true }) + if err != nil { log.Error("error handling storage range request", "err", err) return @@ -291,42 +314,50 @@ func (b *snapServer) GetStorageRange(ctx context.Context, request *StorageRangeR break } } + + yield(finMsg) }, nil } -// GetStorageRangeStd TODO: move/change 👆 - just to check it can work on spec structs -func (b *snapServer) GetStorageRangeStd(ctx context.Context, request *spec.ContractStorageRequest) (iter.Seq[*StorageRangeStreamingResult], error) { - req := &StorageRangeRequest{ - StateRoot: p2p2core.AdaptHash(request.StateRoot), - Queries: request.Query, - ChunkPerProof: uint64(request.ChunksPerProof), +func (b *snapServer) GetClasses(request *spec.ClassHashesRequest) (iter.Seq[proto.Message], error) { + var finMsg proto.Message = &spec.ClassesResponse{ + ClassMessage: &spec.ClassesResponse_Fin{}, } - return b.GetStorageRange(ctx, req) -} -func (b *snapServer) GetClasses(ctx context.Context, felts []*felt.Felt) ([]*spec.Class, error) { - classes := make([]*spec.Class, len(felts)) - coreClasses, err := b.blockchain.GetClasses(felts) - if err != nil { - return nil, err - } + return func(yield yieldFunc) { + felts := make([]*felt.Felt, len(request.ClassHashes)) + for _, hash := range request.ClassHashes { + felts = append(felts, p2p2core.AdaptHash(hash)) + } - for i, class := range coreClasses { - classes[i] = core2p2p.AdaptClass(class) - } + coreClasses, err := b.blockchain.GetClasses(felts) + if err != nil { + log.Error("error getting classes", "err", err) + return + } + + for _, cls := range coreClasses { + clsMsg := &spec.ClassesResponse{ + ClassMessage: &spec.ClassesResponse_Class{ + Class: core2p2p.AdaptClass(cls), + }, + } + if !yield(clsMsg) { + break + } + } - return classes, nil + yield(finMsg) + }, nil } func (b *snapServer) handleStorageRangeRequest( - ctx context.Context, stTrie *trie.Trie, request *spec.StorageRangeQuery, - maxChunkPerProof uint64, - nodeLimit uint64, - yield func([]*spec.ContractStoredValue, []trie.ProofNode), -) (int64, error) { - totalSent := int64(0) + maxChunkPerProof, nodeLimit uint32, + yield func([]*spec.ContractStoredValue, []trie.ProofNode) bool, +) (uint32, error) { + totalSent := 0 finished := false startAddr := p2p2core.AdaptFelt(request.Start.Key) var endAddr *felt.Felt = nil @@ -335,10 +366,6 @@ func (b *snapServer) handleStorageRangeRequest( } for !finished { - if ctxErr := ctx.Err(); ctxErr != nil { - return totalSent, ctxErr - } - response := []*spec.ContractStoredValue{} limit := maxChunkPerProof @@ -365,9 +392,11 @@ func (b *snapServer) handleStorageRangeRequest( finished = true } - yield(response, proofs) + if !yield(response, proofs) { + finished = true + } - totalSent += int64(len(response)) + totalSent += len(response) nodeLimit -= limit asBint := startAddr.BigInt(big.NewInt(0)) @@ -375,21 +404,21 @@ func (b *snapServer) handleStorageRangeRequest( startAddr = startAddr.SetBigInt(asBint) } - return totalSent, nil + return uint32(totalSent), nil } func iterateWithLimit( srcTrie *trie.Trie, startAddr *felt.Felt, limitAddr *felt.Felt, - maxNodes uint64, + maxNodes uint32, consumer func(key, value *felt.Felt) error, ) ([]trie.ProofNode, bool, error) { pathes := make([]*felt.Felt, 0) hashes := make([]*felt.Felt, 0) // TODO: Verify class trie - count := uint64(0) + count := uint32(0) proof, finished, err := srcTrie.IterateAndGenerateProof(startAddr, func(key *felt.Felt, value *felt.Felt) (bool, error) { // Need at least one. if limitAddr != nil && key.Cmp(limitAddr) > 1 && count > 0 { diff --git a/sync/snap_server_test.go b/p2p/snap_server_test.go similarity index 84% rename from sync/snap_server_test.go rename to p2p/snap_server_test.go index 6b4c92e4d6..ea85ee4137 100644 --- a/sync/snap_server_test.go +++ b/p2p/snap_server_test.go @@ -1,10 +1,8 @@ -package sync +package p2p import ( "context" - "errors" "fmt" - "github.com/NethermindEth/juno/core/trie" "testing" "github.com/NethermindEth/juno/adapters/core2p2p" @@ -22,7 +20,7 @@ import ( func TestClassRange(t *testing.T) { var d db.DB - t.Skip("DB snapshot is needed for this test") + //t.Skip("DB snapshot is needed for this test") d, _ = pebble.NewWithOptions("/Users/pnowosie/juno/snapshots/juno-sepolia", 128000000, 128, false) defer func() { _ = d.Close() }() bc := blockchain.New(d, &utils.Sepolia) // Needed because class loader need encoder to be registered @@ -207,39 +205,3 @@ func feltFromString(str string) *felt.Felt { } return f } - -// TODO: Duplicated methods - maybe they belongs to `sync` or `p2p` - will see -func VerifyGlobalStateRoot(globalStateRoot, classRoot, storageRoot *felt.Felt) error { - var stateVersion = new(felt.Felt).SetBytes([]byte(`STARKNET_STATE_V0`)) - - if classRoot.IsZero() { - if globalStateRoot.Equal(storageRoot) { - return nil - } else { - return errors.New("invalid global state root") - } - } - - if !crypto.PoseidonArray(stateVersion, storageRoot, classRoot).Equal(globalStateRoot) { - return errors.New("invalid global state root") - } - return nil -} - -func VerifyTrie( - expectedRoot *felt.Felt, - paths, hashes []*felt.Felt, - proofs []trie.ProofNode, - height uint8, - hash func(*felt.Felt, *felt.Felt) *felt.Felt, -) (bool, error) { - hasMore, valid, err := trie.VerifyRange(expectedRoot, nil, paths, hashes, proofs, hash, height) - if err != nil { - return false, err - } - if !valid { - return false, errors.New("invalid proof") - } - - return hasMore, nil -} diff --git a/p2p/snap_syncer.go b/p2p/snap_syncer.go index 572d84e91a..cb8930cacd 100644 --- a/p2p/snap_syncer.go +++ b/p2p/snap_syncer.go @@ -20,7 +20,6 @@ import ( "github.com/NethermindEth/juno/p2p/starknet/spec" "github.com/NethermindEth/juno/service" "github.com/NethermindEth/juno/starknetdata" - junoSync "github.com/NethermindEth/juno/sync" //TODO: Remove this? "github.com/NethermindEth/juno/utils" "github.com/consensys/gnark-crypto/ecc/stark-curve/fp" "github.com/prometheus/client_golang/prometheus" @@ -43,7 +42,6 @@ type SnapSyncher struct { baseSync service.Service starknetData starknetdata.StarknetData client starknet.Client - snapServer junoSync.SnapServer // TODO: Remove this? blockchain Blockchain log utils.Logger @@ -785,7 +783,7 @@ func (s *SnapSyncher) runStorageRangeWorker(ctx context.Context, workerIdx int) job := jobs[processedJobs] - storageAddr := p2p2core.AdaptFelt(response.ContractAddress) + storageAddr := p2p2core.AdaptAddress(response.ContractAddress) if !job.path.Equal(storageAddr) { s.log.Errorw(fmt.Sprintf( "storage addr differ %s %s %d\n", job.path, storageAddr, workerIdx)) diff --git a/p2p/starknet/handlers.go b/p2p/starknet/handlers.go index eda81645ce..75da79a19d 100644 --- a/p2p/starknet/handlers.go +++ b/p2p/starknet/handlers.go @@ -14,7 +14,6 @@ import ( "github.com/NethermindEth/juno/core" "github.com/NethermindEth/juno/core/felt" "github.com/NethermindEth/juno/p2p/starknet/spec" - junoSync "github.com/NethermindEth/juno/sync" "github.com/NethermindEth/juno/utils" "github.com/NethermindEth/juno/utils/iter" "github.com/libp2p/go-libp2p/core/network" @@ -24,7 +23,7 @@ import ( type Handler struct { bcReader blockchain.Reader - snapProvider *SnapProvider + snapProvider SnapProvider log utils.SimpleLogger ctx context.Context @@ -43,9 +42,9 @@ func NewHandler(bcReader blockchain.Reader, log utils.SimpleLogger) *Handler { } } -func (h *Handler) WithSnapsyncSupport(bc *blockchain.Blockchain) { +func (h *Handler) WithSnapsyncSupport(provider SnapProvider) { // TODO: should it be here? - h.snapProvider = &SnapProvider{SnapServer: junoSync.NewSnapServer(bc)} + h.snapProvider = provider } // bufferPool caches unused buffer objects for later reuse. @@ -138,7 +137,23 @@ func (h *Handler) ClassRangeRequest(stream network.Stream) { h.log.Debugw("SnapProvider not initialized") return } - streamHandler[*spec.ClassRangeRequest](h.ctx, &h.wg, stream, h.onClassRangeRequest, h.log) + streamHandler[*spec.ClassRangeRequest](h.ctx, &h.wg, stream, h.snapProvider.GetClassRange, h.log) +} + +func (h *Handler) ContractRangeRequest(stream network.Stream) { + if h.snapProvider == nil { + h.log.Debugw("SnapProvider not initialized") + return + } + streamHandler[*spec.ContractRangeRequest](h.ctx, &h.wg, stream, h.snapProvider.GetContractRange, h.log) +} + +func (h *Handler) ContractStorageRequest(stream network.Stream) { + if h.snapProvider == nil { + h.log.Debugw("SnapProvider not initialized") + return + } + streamHandler[*spec.ContractStorageRequest](h.ctx, &h.wg, stream, h.snapProvider.GetStorageRange, h.log) } func (h *Handler) ClassHashesRequest(stream network.Stream) { @@ -146,7 +161,7 @@ func (h *Handler) ClassHashesRequest(stream network.Stream) { h.log.Debugw("SnapProvider not initialized") return } - streamHandler[*spec.ClassHashesRequest](h.ctx, &h.wg, stream, h.onClassHashesRequest, h.log) + streamHandler[*spec.ClassHashesRequest](h.ctx, &h.wg, stream, h.snapProvider.GetClasses, h.log) } func (h *Handler) onHeadersRequest(req *spec.BlockHeadersRequest) (iter.Seq[proto.Message], error) { diff --git a/p2p/starknet/snap_provider.go b/p2p/starknet/snap_provider.go index 62fe135514..8832a9f6ac 100644 --- a/p2p/starknet/snap_provider.go +++ b/p2p/starknet/snap_provider.go @@ -1,131 +1,14 @@ package starknet import ( - "fmt" - "github.com/NethermindEth/juno/adapters/core2p2p" - "github.com/NethermindEth/juno/adapters/p2p2core" - "github.com/NethermindEth/juno/core/felt" "github.com/NethermindEth/juno/p2p/starknet/spec" - "github.com/NethermindEth/juno/sync" "github.com/NethermindEth/juno/utils/iter" "google.golang.org/protobuf/proto" ) -type SnapProvider struct { - SnapServer sync.SnapServer -} - -func (h *Handler) onClassHashesRequest(req *spec.ClassHashesRequest) (iter.Seq[proto.Message], error) { - type yieldFunc = func(proto.Message) bool - finMsg := &spec.ClassesResponse{ - ClassMessage: &spec.ClassesResponse_Fin{}, - } - - return func(yield yieldFunc) { - if req == nil || req.ClassHashes == nil || len(req.ClassHashes) == 0 { - yield(finMsg) - return - } - - // Since we return iterator we may split given keys into smaller chunks if necessary - classHashes := make([]*felt.Felt, len(req.ClassHashes)) - for _, hash := range req.ClassHashes { - classHashes = append(classHashes, p2p2core.AdaptHash(hash)) - } - - classes, err := h.snapProvider.SnapServer.GetClasses(h.ctx, classHashes) - if err != nil { - h.log.Errorw("failed to get classes", "err", err) - return - } - - for _, cls := range classes { - msg := &spec.ClassesResponse{ - ClassMessage: &spec.ClassesResponse_Class{ - Class: cls, - }, - } - if !yield(msg) { - // if caller is not interested in remaining data (example: connection to a peer is closed) exit - // note that in this case we won't send finMsg - return - } - } - - yield(finMsg) - }, nil -} - -func (h *Handler) onClassRangeRequest(req *spec.ClassRangeRequest) (iter.Seq[proto.Message], error) { - if h.snapProvider == nil { - return nil, fmt.Errorf("snapsyncing not supported") - } - - finMsg := &spec.ClassRangeResponse{ - Responses: &spec.ClassRangeResponse_Fin{}, - } - - return func(yield func(message proto.Message) bool) { - // port snap_server here - yield(finMsg) - }, nil -} - -func (h *Handler) onContractRangeRequest(req *spec.ContractRangeRequest) (iter.Seq[proto.Message], error) { - if h.snapProvider == nil { - return nil, fmt.Errorf("snapsyncing not supported") - } - - finMsg := &spec.ContractRangeResponse{ - Responses: &spec.ContractRangeResponse_Fin{}, - } - - return func(yield func(message proto.Message) bool) { - // port snap_server here - yield(finMsg) - }, nil -} - -func (h *Handler) onContractStorageRequest(req *spec.ContractStorageRequest) (iter.Seq[proto.Message], error) { - if h.snapProvider == nil { - return nil, fmt.Errorf("snapsyncing not supported") - } - - finMsg := &spec.ContractStorageResponse{ - Responses: &spec.ContractStorageResponse_Fin{}, - } - return func(yield func(message proto.Message) bool) { - // TODO: adapter method? Do we need separate req/res structs? - srr := &sync.StorageRangeRequest{ - StateRoot: p2p2core.AdaptHash(req.StateRoot), - ChunkPerProof: uint64(req.ChunksPerProof), - Queries: req.Query, - } - stoIter, err := h.snapProvider.SnapServer.GetStorageRange(h.ctx, srr) - if err != nil { - h.log.Errorw("failed to get storage range", "err", err) - return - } - - stoIter(func(result *sync.StorageRangeStreamingResult) bool { - // TODO: again adapter or just return spec types? - res := &spec.ContractStorageResponse{ - StateRoot: req.StateRoot, - ContractAddress: core2p2p.AdaptFelt(result.StorageAddr), - Responses: &spec.ContractStorageResponse_Storage{ - Storage: &spec.ContractStorage{ - KeyValue: result.Range, - }, - }, - } - - if !yield(res) { - return false - } - - return true - }) - - yield(finMsg) - }, nil +type SnapProvider interface { + GetClassRange(request *spec.ClassRangeRequest) (iter.Seq[proto.Message], error) + GetContractRange(request *spec.ContractRangeRequest) (iter.Seq[proto.Message], error) + GetStorageRange(request *spec.ContractStorageRequest) (iter.Seq[proto.Message], error) + GetClasses(request *spec.ClassHashesRequest) (iter.Seq[proto.Message], error) } diff --git a/p2p/starknet/spec/snapshot.pb.go b/p2p/starknet/spec/snapshot.pb.go index f904de747b..fd6ee7f3a6 100644 --- a/p2p/starknet/spec/snapshot.pb.go +++ b/p2p/starknet/spec/snapshot.pb.go @@ -894,7 +894,7 @@ type ContractStorageResponse struct { unknownFields protoimpl.UnknownFields StateRoot *Hash `protobuf:"bytes,1,opt,name=state_root,json=stateRoot,proto3,oneof" json:"state_root,omitempty"` // may not appear if Fin is sent to end the whole response - ContractAddress *Felt252 `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3,oneof" json:"contract_address,omitempty"` + ContractAddress *Address `protobuf:"bytes,2,opt,name=contract_address,json=contractAddress,proto3,oneof" json:"contract_address,omitempty"` // Types that are assignable to Responses: // // *ContractStorageResponse_Storage @@ -942,7 +942,7 @@ func (x *ContractStorageResponse) GetStateRoot() *Hash { return nil } -func (x *ContractStorageResponse) GetContractAddress() *Felt252 { +func (x *ContractStorageResponse) GetContractAddress() *Address { if x != nil { return x.ContractAddress } @@ -1252,7 +1252,7 @@ var file_p2p_proto_snapshot_proto_rawDesc = []byte{ 0x05, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x48, 0x01, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x88, 0x01, 0x01, 0x12, 0x38, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x08, 0x2e, 0x46, 0x65, 0x6c, 0x74, 0x32, 0x35, 0x32, 0x48, 0x02, 0x52, 0x0f, 0x63, 0x6f, + 0x32, 0x08, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x48, 0x02, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x88, 0x01, 0x01, 0x12, 0x2c, 0x0a, 0x07, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x53, 0x74, 0x6f, 0x72, @@ -1339,7 +1339,7 @@ var file_p2p_proto_snapshot_proto_depIdxs = []int32{ 9, // 31: ContractStorageRequest.query:type_name -> StorageRangeQuery 20, // 32: ContractStorage.keyValue:type_name -> ContractStoredValue 16, // 33: ContractStorageResponse.state_root:type_name -> Hash - 19, // 34: ContractStorageResponse.contract_address:type_name -> Felt252 + 15, // 34: ContractStorageResponse.contract_address:type_name -> Address 11, // 35: ContractStorageResponse.storage:type_name -> ContractStorage 17, // 36: ContractStorageResponse.fin:type_name -> Fin 1, // 37: ContractStorageResponse.range_proof:type_name -> PatriciaRangeProof