@lightprotocol/stateless.js 0.22.1-alpha.0 → 0.22.1-alpha.2

package/dist/es/browser/rpc.d.ts

@@ -0,0 +1,361 @@
+import { AccountInfo, Commitment, Connection, ConnectionConfig, GetAccountInfoConfig, PublicKey, SignaturesForAddressOptions } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import { ValidityProofWithContext, CompressedTransaction, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, HexInputsForProver, ParsedTokenAccount, SignatureWithMetadata, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, WithContext, GetCompressedAccountsByOwnerConfig, WithCursor, AddressWithTree, HashWithTree, CompressedMintTokenHolders, TokenBalance, PaginatedOptions, DerivationMode, AddressWithTreeInfoV2, SignaturesForAddressInterfaceResult, UnifiedSignatureInfo, UnifiedTokenBalance, UnifiedBalance } from './rpc-interface';
+import { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext, ValidityProof, AddressTreeInfo, MerkleContext } from './state';
+import BN from 'bn.js';
+import { ConfirmedSignatureInfo } from '@solana/web3.js';
+import { LightWasm } from './test-helpers';
+import { TreeInfo } from './state/types';
+/** @internal */
+export declare function parseAccountData({ discriminator, data, dataHash, }: {
+    discriminator: BN;
+    data: string;
+    dataHash: BN;
+}): {
+    discriminator: number[];
+    data: Buffer<ArrayBuffer>;
+    dataHash: number[];
+};
+/**
+ * Establish a Compression-compatible JSON RPC connection
+ *
+ * @param endpointOrWeb3JsConnection    endpoint to the solana cluster or
+ *                                      Connection object
+ * @param compressionApiEndpoint        Endpoint to the compression server
+ * @param proverEndpoint                Endpoint to the prover server. defaults
+ *                                      to endpoint
+ * @param connectionConfig              Optional connection config
+ */
+export declare function createRpc(endpointOrWeb3JsConnection?: string | Connection, compressionApiEndpoint?: string, proverEndpoint?: string, config?: ConnectionConfig): Rpc;
+/**
+ * Helper function to preprocess the response to wrap numbers as strings
+ * @param {string} text - The JSON string to preprocess
+ * @returns {string} - The preprocessed JSON string with numbers wrapped as strings
+ */
+export declare function wrapBigNumbersAsStrings(text: string): string;
+/** @internal */
+export declare const rpcRequest: (rpcEndpoint: string, method: string, params?: any, convertToCamelCase?: boolean, debug?: boolean) => Promise<any>;
+/** @internal */
+export declare const proverRequest: (proverEndpoint: string, method: "inclusion" | "new-address" | "combined", params?: any, log?: boolean, _publicInputHash?: BN | undefined) => Promise<ValidityProof>;
+export type NonInclusionMerkleProofInputs = {
+    root: BN;
+    value: BN;
+    leaf_lower_range_value: BN;
+    leaf_higher_range_value: BN;
+    nextIndex: BN;
+    merkle_proof_hashed_indexed_element_leaf: BN[];
+    index_hashed_indexed_element_leaf: BN;
+};
+export type MerkleContextWithNewAddressProof = {
+    root: BN;
+    rootIndex: number;
+    value: BN;
+    leafLowerRangeValue: BN;
+    leafHigherRangeValue: BN;
+    nextIndex: BN;
+    merkleProofHashedIndexedElementLeaf: BN[];
+    indexHashedIndexedElementLeaf: BN;
+    treeInfo: AddressTreeInfo;
+};
+export type NonInclusionJsonStruct = {
+    root: string;
+    value: string;
+    pathIndex: number;
+    pathElements: string[];
+    leafLowerRangeValue: string;
+    leafHigherRangeValue: string;
+    nextIndex: number;
+};
+export declare function convertMerkleProofsWithContextToHex(merkleProofsWithContext: MerkleContextWithMerkleProof[]): HexInputsForProver[];
+export declare function convertNonInclusionMerkleProofInputsToHex(nonInclusionMerkleProofInputs: MerkleContextWithNewAddressProof[]): NonInclusionJsonStruct[];
+export declare function getPublicInputHash(accountProofs: MerkleContextWithMerkleProof[], accountHashes: BN254[], newAddressProofs: MerkleContextWithNewAddressProof[], lightWasm: LightWasm): BN;
+export interface NullifierMetadata {
+    nullifier: BN254;
+    txHash: BN254;
+}
+/**
+ * Merge signatures from Solana RPC and compression indexer.
+ * Deduplicates by signature, tracking sources in the `sources` array.
+ * When a signature exists in both, uses Solana data (richer) but marks both sources.
+ */
+export declare function mergeSignatures(solanaSignatures: ConfirmedSignatureInfo[], compressedSignatures: SignatureWithMetadata[]): UnifiedSignatureInfo[];
+/**
+ *
+ */
+export declare class Rpc extends Connection implements CompressionApiInterface {
+    compressionApiEndpoint: string;
+    proverEndpoint: string;
+    allStateTreeInfos: TreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    CACHE_TTL: number;
+    fetchPromise: Promise<TreeInfo[]> | null;
+    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
+    /**
+     * @deprecated Use {@link getStateTreeInfos} instead
+     */
+    getCachedActiveStateTreeInfo(): Promise<void>;
+    /**
+     * @deprecated Use {@link getStateTreeInfos} instead
+     */
+    getCachedActiveStateTreeInfos(): Promise<void>;
+    /**
+     * Get a list of all state tree infos. If not already cached, fetches from
+     * the cluster.
+     */
+    getStateTreeInfos(): Promise<TreeInfo[]>;
+    /**
+     * @internal
+     */
+    doFetch(): Promise<TreeInfo[]>;
+    /**
+     * Get a V2 address tree info.
+     */
+    getAddressTreeInfoV2(): Promise<TreeInfo>;
+    /**
+     * Fetch the compressed account for the specified account address or hash
+     */
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
+    /**
+     * Fetch the compressed balance for the specified account address or hash
+     */
+    getCompressedBalance(address?: BN254, hash?: BN254): Promise<BN>;
+    /**
+     * Fetch the total compressed balance for the specified owner public key
+     */
+    getCompressedBalanceByOwner(owner: PublicKey): Promise<BN>;
+    /**
+     * Fetch the latest merkle proof for the specified account hash from the
+     * cluster
+     */
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
+    /**
+     * Fetch all the account info for multiple compressed accounts specified by
+     * an array of account hashes
+     */
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
+    /**
+     * Fetch the latest merkle proofs for multiple compressed accounts specified
+     * by an array account hashes
+     */
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
+    /**
+     * Fetch all the compressed accounts owned by the specified public key.
+     * Owner can be a program or user account
+     */
+    getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig | undefined): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    /**
+     * Fetch all the compressed token accounts owned by the specified public
+     * key. Owner can be a program or user account
+     */
+    getCompressedTokenAccountsByOwner(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
+    /**
+     * Fetch all the compressed accounts delegated to the specified public key.
+     */
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
+    /**
+     * Fetch the compressed token balance for the specified account hash
+     */
+    getCompressedTokenAccountBalance(hash: BN254): Promise<{
+        amount: BN;
+    }>;
+    /**
+     * @deprecated use {@link getCompressedTokenBalancesByOwnerV2} instead.
+     *
+     * Fetch all the compressed token balances owned by the specified public
+     * key. Can filter by mint. Returns without context.
+     */
+    getCompressedTokenBalancesByOwner(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<TokenBalance[]>>;
+    /**
+     * Fetch the compressed token balances owned by the specified public
+     * key. Paginated. Can filter by mint. Returns with context.
+     */
+    getCompressedTokenBalancesByOwnerV2(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    /**
+     * Returns confirmed compression signatures for transactions involving the specified
+     * account hash forward in time from genesis to the most recent confirmed
+     * block
+     *
+     * @param hash queried account hash
+     */
+    getCompressionSignaturesForAccount(hash: BN254): Promise<SignatureWithMetadata[]>;
+    /**
+     * Fetch a confirmed or finalized transaction from the cluster. Return with
+     * CompressionInfo
+     */
+    getTransactionWithCompressionInfo(signature: string): Promise<CompressedTransaction | null>;
+    /**
+     * Returns confirmed signatures for transactions involving the specified
+     * address forward in time from genesis to the most recent confirmed block
+     *
+     * @param address queried compressed account address
+     */
+    getCompressionSignaturesForAddress(address: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    /**
+     * Returns confirmed signatures for compression transactions involving the
+     * specified account owner forward in time from genesis to the
+     * most recent confirmed block
+     *
+     * @param owner queried owner public key
+     */
+    getCompressionSignaturesForOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    /**
+     * Returns confirmed signatures for compression transactions involving the
+     * specified token account owner forward in time from genesis to the most
+     * recent confirmed block
+     */
+    getCompressionSignaturesForTokenOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    /**
+     * Fetch the current indexer health status
+     */
+    getIndexerHealth(): Promise<string>;
+    /**
+     * Ensure that the Compression Indexer has already indexed the transaction
+     */
+    confirmTransactionIndexed(slot: number): Promise<boolean>;
+    /**
+     * Fetch the current slot that the node is processing
+     */
+    getIndexerSlot(): Promise<number>;
+    /**
+     * Fetch all the compressed token holders for a given mint. Paginated.
+     */
+    getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
+    /**
+     * Fetch the latest compression signatures on the cluster. Results are
+     * paginated.
+     */
+    getLatestCompressionSignatures(cursor?: string, limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
+    /**
+     * Fetch all non-voting signatures
+     */
+    getLatestNonVotingSignatures(limit?: number, cursor?: string): Promise<LatestNonVotingSignatures>;
+    /**
+     * Fetch the latest address proofs for new unique addresses specified by an
+     * array of addresses.
+     *
+     * the proof states that said address have not yet been created in
+     * respective address tree.
+     * @param addresses Array of BN254 new addresses
+     * @returns Array of validity proofs for new addresses
+     */
+    getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
+    /**
+     * @deprecated use {@link getValidityProofV0} instead.
+     *
+     * Fetch the latest validity proof for (1) compressed accounts specified by
+     * an array of account hashes. (2) new unique addresses specified by an
+     * array of addresses.
+     *
+     * Validity proofs prove the presence of compressed accounts in state trees
+     * and the non-existence of addresses in address trees, respectively. They
+     * enable verification without recomputing the merkle proof path, thus
+     * lowering verification and data costs.
+     *
+     * @param hashes        Array of BN254 hashes.
+     * @param newAddresses  Array of BN254 new addresses.
+     * @returns             validity proof with context
+     */
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
+    /**
+     * Fetch the latest validity proof for (1) compressed accounts specified by
+     * an array of account hashes. (2) new unique addresses specified by an
+     * array of addresses.
+     *
+     * Validity proofs prove the presence of compressed accounts in state trees
+     * and the non-existence of addresses in address trees, respectively. They
+     * enable verification without recomputing the merkle proof path, thus
+     * lowering verification and data costs.
+     *
+     * @param hashes        Array of { hash: BN254, tree: PublicKey, queue: PublicKey }.
+     * @param newAddresses  Array of { address: BN254, tree: PublicKey, queue: PublicKey }.
+     * @returns             validity proof with context
+     */
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    /**
+     * Fetch the latest validity proof for (1) compressed accounts specified by
+     * an array of account Merkle contexts, and (2) new unique addresses specified by
+     * an array of address objects with tree info.
+     *
+     * Validity proofs prove the presence of compressed accounts in state trees
+     * and the non-existence of addresses in address trees, respectively. They
+     * enable verification without recomputing the merkle proof path, thus
+     * lowering verification and data costs.
+     */
+    getValidityProofV2(accountMerkleContexts?: (MerkleContext | undefined)[], newAddresses?: AddressWithTreeInfoV2[], derivationMode?: DerivationMode): Promise<ValidityProofWithContext>;
+    /**
+     * Fetch the latest validity proof for (1) compressed accounts specified by
+     * an array of account hashes. (2) new unique addresses specified by an
+     * array of addresses. Returns with context slot.
+     *
+     * Validity proofs prove the presence of compressed accounts in state trees
+     * and the non-existence of addresses in address trees, respectively. They
+     * enable verification without recomputing the merkle proof path, thus
+     * lowering verification and data costs.
+     *
+     * @param hashes        Array of BN254 hashes.
+     * @param newAddresses  Array of BN254 new addresses. Optionally specify the
+     *                      tree and queue for each address. Default to public
+     *                      state tree/queue.
+     * @returns             validity proof with context
+     */
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
+    /**
+     * Fetch the account info for the specified public key. Returns metadata
+     * to load in case the account is cold.
+     * @param address               The account address to fetch.
+     * @param programId             The owner program ID.
+     * @param commitmentOrConfig    Optional. The commitment or config to use
+     *                              for the onchain account fetch.
+     * @param addressSpace          Optional. The address space info that was
+     *                              used at init.
+     *
+     * @returns                     Account info with load info, or null if
+     *                              account doesn't exist. LoadContext is always
+     *                              some if the account is compressible. isCold
+     *                              indicates the current state of the account,
+     *                              if true the account must referenced in a
+     *                              load instruction before use.
+     */
+    getAccountInfoInterface(address: PublicKey, programId: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig, addressSpace?: TreeInfo): Promise<{
+        accountInfo: AccountInfo<Buffer>;
+        isCold: boolean;
+        loadContext?: MerkleContext;
+    } | null>;
+    /**
+     * Get signatures for an address from both Solana and compression indexer.
+     *
+     * @param address               Address to fetch signatures for.
+     * @param options               Options for the Solana getSignaturesForAddress call.
+     * @param compressedOptions     Options for the compression getCompressionSignaturesForAddress call.
+     * @returns                     Unified signatures from both sources.
+     */
+    getSignaturesForAddressInterface(address: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    /**
+     * Get signatures for an owner from both Solana and compression indexer.
+     *
+     * @param owner                 Owner address to fetch signatures for.
+     * @param options               Options for the Solana getSignaturesForAddress call.
+     * @param compressedOptions     Options for the compression getCompressionSignaturesForOwner call.
+     * @returns                     Unified signatures from both sources.
+     */
+    getSignaturesForOwnerInterface(owner: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    /**
+     * Get token account balance for an address, regardless of whether the token
+     * account is hot or cold.
+     *
+     * @param address       Token account address.
+     * @param owner         Owner public key.
+     * @param mint          Mint public key.
+     * @param commitment    Commitment level for on-chain query.
+     * @returns             Unified token balance from both sources.
+     */
+    getTokenAccountBalanceInterface(address: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment): Promise<UnifiedTokenBalance>;
+    /**
+     * Get SOL balance for an address, regardless of whether the account is hot or cold.
+     *
+     * @param address       Address to fetch balance for.
+     * @param commitment    Commitment level for on-chain query.
+     * @returns             Unified SOL balance.
+     */
+    getBalanceInterface(address: PublicKey, commitment?: Commitment): Promise<UnifiedBalance>;
+}

package/dist/es/browser/state/BN254.d.ts

@@ -0,0 +1,13 @@
+import BN from 'bn.js';
+import { Buffer } from 'buffer';
+/**
+ * bignumber with <254-bit max size. Anchor serialization doesn't support native
+ * bigint yet, so we wrap BN. This wrapper has simple base10 encoding which is
+ * needed for zk circuit compat, in addition to the base58 encoding that users
+ * are used to from working with the web3.js PublicKey type.
+ */
+export type BN254 = BN;
+/** Create a bigint instance with <254-bit max size and base58 capabilities */
+export declare const createBN254: (number: string | number | BN | Buffer | Uint8Array | number[], base?: number | "hex" | "base58" | undefined) => BN254;
+/** Convert <254-bit bigint to Base58 string.  */
+export declare function encodeBN254toBase58(bigintNumber: BN): string;

package/dist/es/browser/state/bn.d.ts

@@ -0,0 +1,3 @@
+import BN from 'bn.js';
+import { Buffer } from 'buffer';
+export declare const bn: (number: string | number | BN | Buffer | Uint8Array | number[], base?: number | "hex" | undefined, endian?: BN.Endianness | undefined) => BN;

package/dist/es/browser/state/compressed-account.d.ts

@@ -0,0 +1,205 @@
+import { PublicKey } from '@solana/web3.js';
+import { CompressedAccountData, CompressedAccountLegacy, PackedMerkleContextLegacy, TreeInfo } from './types';
+import BN from 'bn.js';
+import { BN254 } from './BN254';
+/**
+ * @deprecated use {@link CompressedAccount} instead
+ */
+export type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext & {
+    readOnly: boolean;
+};
+/**
+ * @deprecated use {@link CompressedAccount} instead
+ */
+export type CompressedAccountWithMerkleContextLegacy = CompressedAccount & MerkleContext;
+/**
+ * Compressed account + metadata about the state tree in which the account is
+ * stored.
+ */
+export type CompressedAccount = {
+    /**
+     * Public key of program or user owning the account.
+     */
+    owner: PublicKey;
+    /**
+     * Lamports attached to the account.
+     */
+    lamports: BN;
+    /**
+     * Optional unique account ID that is persistent across transactions.
+     */
+    address: number[] | null;
+    /**
+     * Optional data attached to the account.
+     */
+    data: CompressedAccountData | null;
+} & MerkleContext & {
+    /**
+     * Read only.
+     */
+    readOnly: boolean;
+};
+/**
+ * @deprecated use {@link MerkleContext} instead.
+ *
+ * Legacy MerkleContext.
+ */
+export type MerkleContextLegacy = {
+    /**
+     * State tree
+     */
+    merkleTree: PublicKey;
+    /**
+     * Nullifier queue
+     */
+    nullifierQueue: PublicKey;
+    /**
+     * Poseidon hash of the account. Stored as leaf in state tree
+     */
+    hash: number[];
+    /**
+     * Position of `hash` in the State tree
+     */
+    leafIndex: number;
+};
+/**
+ * Context for compressed account stored in a state tree
+ */
+export type MerkleContext = {
+    /**
+     * Tree info
+     */
+    treeInfo: TreeInfo;
+    /**
+     * Poseidon hash of the account. Stored as leaf in state tree
+     */
+    hash: BN;
+    /**
+     * Position of `hash` in the State tree
+     */
+    leafIndex: number;
+    /**
+     * Whether the account can be proven by index or by merkle proof
+     */
+    proveByIndex: boolean;
+};
+/**
+ * MerkleContext with merkle proof
+ */
+export type MerkleContextWithMerkleProof = MerkleContext & {
+    /**
+     * Recent valid 'hash' proof path, expires after n slots
+     */
+    merkleProof: BN254[];
+    /**
+     * Index of state root the merkleproof is valid for, expires after n slots
+     */
+    rootIndex: number;
+    /**
+     * Current root
+     */
+    root: BN254;
+};
+/**
+ * Packed compressed account and state tree info.
+ */
+export type PackedStateTreeInfo = {
+    /**
+     * Recent valid root index.
+     */
+    rootIndex: number;
+    /**
+     * Whether the account can be proven by index or by merkle proof
+     */
+    proveByIndex: boolean;
+    /**
+     * Index of the merkle tree in which the account is stored.
+     */
+    merkleTreePubkeyIndex: number;
+    /**
+     * Index of the queue in which the account is stored.
+     */
+    queuePubkeyIndex: number;
+    /**
+     * Index of the leaf in the state tree.
+     */
+    leafIndex: number;
+};
+/**
+ * Packed tree info for a new program-derived address (PDA).
+ */
+export type PackedAddressTreeInfo = {
+    /**
+     * Index of the merkle tree in which the account is stored.
+     */
+    addressMerkleTreePubkeyIndex: number;
+    /**
+     * Index of the queue in which the account is stored.
+     */
+    addressQueuePubkeyIndex: number;
+    /**
+     * Recent valid root index.
+     */
+    rootIndex: number;
+};
+/**
+ * Compressed account meta in instruction.
+ *
+ */
+export type CompressedAccountMeta = {
+    /**
+     * Packed Tree info.
+     */
+    treeInfo: PackedStateTreeInfo;
+    /**
+     * Address.
+     */
+    address: number[] | null;
+    /**
+     * Lamports.
+     */
+    lamports: BN | null;
+    /**
+     * index of state tree in which the new account state is stored.
+     */
+    outputStateTreeIndex: number;
+};
+/**
+ * Create an output compressed account meta for a new account.
+ * Client-side only.
+ */
+export declare const createCompressedAccountMeta: (treeInfo: PackedStateTreeInfo, outputStateTreeIndex: number, address?: number[], lamports?: BN) => CompressedAccountMeta;
+/**
+ * @deprecated Use {@link PackedStateTreeInfo} instead.
+ * Packed compressed account with merkle context.
+ */
+export interface PackedCompressedAccountWithMerkleContext {
+    /**
+     * Compressed account.
+     */
+    compressedAccount: CompressedAccountLegacy;
+    /**
+     * Merkle context.
+     */
+    merkleContext: PackedMerkleContextLegacy;
+    /**
+     * Root index.
+     */
+    rootIndex: number;
+    /**
+     * Read only.
+     */
+    readOnly: boolean;
+}
+/**
+ * @deprecated use {@link createCompressedAccountMeta} instead.
+ */
+export declare const createCompressedAccountLegacy: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountLegacy;
+/**
+ * @deprecated.
+ */
+export declare const createCompressedAccountWithMerkleContextLegacy: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
+/**
+ * @deprecated use {@link createCompressedAccountMeta} instead.
+ */
+export declare const createMerkleContextLegacy: (treeInfo: TreeInfo, hash: BN254, leafIndex: number, proveByIndex?: boolean) => MerkleContext;

package/dist/es/browser/state/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BN254';
+export * from './bn';
+export * from './compressed-account';
+export * from './types';