StorageProof

func (provider *Provider) StorageProof(
    ctx context.Context,
    storageProofInput StorageProofInput,
) (*StorageProofResult, error)

type StorageProofInput struct {
    // Required. The hash of the requested block, or number (height) of the
    // requested block, or a block tag
    BlockID BlockID `json:"block_id"`
 
    // Optional. A list of the class hashes for which we want to prove
    // membership in the classes trie
    ClassHashes []*felt.Felt `json:"class_hashes,omitempty"`
 
    // Optional. A list of contracts for which we want to prove membership in the
    // global state trie
    ContractAddresses []*felt.Felt `json:"contract_addresses,omitempty"`
 
    // Optional. A list of (contract_address, storage_keys) pairs
    ContractsStorageKeys []ContractStorageKeys `json:"contracts_storage_keys,omitempty"`
}

type BlockID struct {
    Number *uint64    `json:"block_number,omitempty"`
    Hash   *felt.Felt `json:"block_hash,omitempty"`
    Tag    BlockTag   `json:"tag,omitempty"`
}

type ContractStorageKeys struct {
    ContractAddress *felt.Felt   `json:"contract_address"`
    StorageKeys     []*felt.Felt `json:"storage_keys"`
}

type StorageProofResult struct {
    ClassesProof           []NodeHashToNode   `json:"classes_proof"`
    ContractsProof         ContractsProof     `json:"contracts_proof"`
    ContractsStorageProofs [][]NodeHashToNode `json:"contracts_storage_proofs"`
    GlobalRoots            GlobalRoots        `json:"global_roots"`
}

type ContractsProof struct {
    // The nodes in the union of the paths from the contracts tree root to the
    // requested leaves
    Nodes              []NodeHashToNode     `json:"nodes"`
    ContractLeavesData []ContractLeavesData `json:"contract_leaves_data"`
}

type ContractLeavesData struct {
    Nonce       *felt.Felt `json:"nonce"`
    ClassHash   *felt.Felt `json:"class_hash"`
    StorageRoot *felt.Felt `json:"storage_root,omitempty"`
}

type GlobalRoots struct {
    ContractsTreeRoot *felt.Felt `json:"contracts_tree_root"`
    ClassesTreeRoot   *felt.Felt `json:"classes_tree_root"`
    // the associated block hash (needed in case the caller used a block tag
    // for the block_id parameter)
    BlockHash *felt.Felt `json:"block_hash"`
}

type NodeHashToNode struct {
    NodeHash *felt.Felt `json:"node_hash"`
    Node     MerkleNode `json:"node"`
}

type MerkleNode struct {
    Type string
    Data any
}

type EdgeNode struct {
    // an unsigned integer whose binary representation represents the path from
    // the current node to its highest non-zero descendant (bounded by 2^251)
    Path NumAsHex `json:"path"`
    // the length of the path (bounded by 251)
    Length uint `json:"length"`
    // the hash of the unique non-zero maximal-height descendant node
    Child *felt.Felt `json:"child"`
}

type BinaryNode struct {
    // the hash of the left child
    Left *felt.Felt `json:"left"`
    // the hash of the right child
    Right *felt.Felt `json:"right"`
}

package main
 
import (
    "context"
    "fmt"
    "log"
    "os"
 
    "github.com/NethermindEth/juno/core/felt"
    "github.com/NethermindEth/starknet.go/rpc"
    "github.com/joho/godotenv"
)
 
func main() {
    // Load environment variables from .env file
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }
 
    // Get RPC URL from environment variable
    rpcURL := os.Getenv("STARKNET_RPC_URL")
    if rpcURL == "" {
        log.Fatal("STARKNET_RPC_URL not found in .env file")
    }
 
    // Initialize provider
    provider, err := rpc.NewProvider(context.Background(), rpcURL)
    if err != nil {
        log.Fatal(err)
    }
 
    ctx := context.Background()
 
    // Contract address to get storage proof for
    contractAddr, _ := new(felt.Felt).SetString("0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7")
 
    // Storage keys to prove
    storageKey1, _ := new(felt.Felt).SetString("0x1")
    storageKey2, _ := new(felt.Felt).SetString("0x2")
 
    // Create storage proof input
    input := rpc.StorageProofInput{
        BlockID: rpc.WithBlockTag("latest"),
        ContractsStorageKeys: []rpc.ContractStorageKeys{
            {
                ContractAddress: contractAddr,
                StorageKeys:     []*felt.Felt{storageKey1, storageKey2},
            },
        },
    }
 
    // Get storage proof
    proof, err := provider.StorageProof(ctx, input)
    if err != nil {
        log.Fatal(err)
    }
 
    // Access proof data
    fmt.Printf("Contracts Tree Root: %s\n", proof.GlobalRoots.ContractsTreeRoot)
    fmt.Printf("Classes Tree Root: %s\n", proof.GlobalRoots.ClassesTreeRoot)
    fmt.Printf("Block Hash: %s\n", proof.GlobalRoots.BlockHash)
    fmt.Printf("Number of contract proof nodes: %d\n", len(proof.ContractsProof.Nodes))
    fmt.Printf("Number of storage proofs: %d\n", len(proof.ContractsStorageProofs))
}

proof, err := provider.StorageProof(ctx, input)
if err != nil {
    if errors.Is(err, rpc.ErrBlockNotFound) {
        log.Printf("Block not found")
        return
    }
    if errors.Is(err, rpc.ErrStorageProofNotSupported) {
        log.Printf("Node doesn't support storage proofs")
        return
    }
    log.Printf("Error retrieving storage proof: %v", err)
    return
}
 
// Verify proof has expected data
if len(proof.ContractsStorageProofs) == 0 {
    log.Printf("Warning: No storage proofs returned")
}