@unruggable/gateways/dist/types/starknet/StarknetProver.d.ts

Trustless Ethereum Multichain CCIP-Read Gateway

import { HexString, ProofSequence, HexString32, Provider } from '../types.js';
import { AbstractProver, Need } from '../vm.js';
type RPCStarknetBlock = {
    block_hash: HexString32;
    block_number: number;
    new_root: HexString32;
    parent_hash: HexString32;
    sequencer_address: HexString32;
    starknet_version: string;
    status: 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
    timestamp: number;
    transactions: HexString32[];
};
type StarknetProofBinary = {
    binary: {
        left: HexString32;
        right: HexString32;
    };
};
type StarknetProofEdge = {
    edge: {
        child: HexString32;
        path: {
            value: HexString;
            len: number;
        };
    };
};
type StarknetStorageProof = (StarknetProofBinary | StarknetProofEdge)[];
type StarknetContractProofHeader = {
    class_commitment: HexString32;
    state_commitment: HexString32;
    contract_proof: StarknetStorageProof;
};
type StarknetContractMissing = StarknetContractProofHeader & {
    contract_data: null;
};
type StarknetContractProof = StarknetContractProofHeader & {
    contract_data: {
        class_hash: HexString32;
        root: HexString32;
        nonce: HexString;
        storage_proofs: StarknetStorageProof[];
    };
};
type RPCStarknetGetProofs = StarknetContractProof | StarknetContractMissing;
export declare class StarknetProver extends AbstractProver {
    static latest(provider: Provider): Promise<StarknetProver>;
    readonly blockId: {
        block_number: number;
    };
    constructor(provider: Provider, block: number);
    get context(): {
        block: number;
    };
    get blockNumber(): number;
    fetchBlock(): Promise<RPCStarknetBlock>;
    fetchStateRoot(): Promise<HexString32>;
    fetchTimestamp(): Promise<number>;
    isContract(target: HexString32, fast?: boolean): Promise<boolean>;
    getStorage(target: HexString32, slot: bigint, fast?: boolean): Promise<HexString>;
    prove(_needs: Need[]): Promise<ProofSequence>;
    getProofs(target: HexString32, slots?: bigint[]): Promise<RPCStarknetGetProofs>;
    fetchProofs(target: HexString32, slots?: bigint[]): Promise<RPCStarknetGetProofs>;
}
export {};
//# sourceMappingURL=StarknetProver.d.ts.map