@lightprotocol/stateless.js 0.20.8 → 0.21.0

package/dist/cjs/node/rpc.d.ts

@@ -1,10 +1,10 @@
 import { Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
 import { Buffer } from 'buffer';
-import { CompressedProofWithContext, CompressedTransaction, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, HexInputsForProver, ParsedTokenAccount, SignatureWithMetadata, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, WithContext, GetCompressedAccountsByOwnerConfig, WithCursor, AddressWithTree, HashWithTree, CompressedMintTokenHolders, TokenBalance, PaginatedOptions } from './rpc-interface';
-import { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext, CompressedProof } from './state';
+import { ValidityProofWithContext, CompressedTransaction, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, HexInputsForProver, ParsedTokenAccount, SignatureWithMetadata, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, WithContext, GetCompressedAccountsByOwnerConfig, WithCursor, AddressWithTree, HashWithTree, CompressedMintTokenHolders, TokenBalance, PaginatedOptions } from './rpc-interface';
+import { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext, ValidityProof, AddressTreeInfo } from './state';
 import BN from 'bn.js';
 import { LightWasm } from './test-helpers';
-import { ActiveTreeBundle } from './state/types';
+import { StateTreeInfo } from './state/types';
 /** @internal */
 export declare function parseAccountData({ discriminator, data, dataHash, }: {
     discriminator: BN;
@@ -35,7 +35,7 @@ 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<CompressedProof>;
+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;
@@ -54,8 +54,7 @@ export type MerkleContextWithNewAddressProof = {
     nextIndex: BN;
     merkleProofHashedIndexedElementLeaf: BN[];
     indexHashedIndexedElementLeaf: BN;
-    merkleTree: PublicKey;
-    nullifierQueue: PublicKey;
+    treeInfo: AddressTreeInfo;
 };
 export type NonInclusionJsonStruct = {
     root: string;
@@ -69,14 +68,6 @@ export type NonInclusionJsonStruct = {
 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;
-/**
- * Get the queue for a given tree
- *
- * @param info - The active state tree addresses
- * @param tree - The tree to get the queue for
- * @returns The queue for the given tree, or undefined if not found
- */
-export declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKey): PublicKey;
 /**
  * Get the tree for a given queue
  *
@@ -84,40 +75,31 @@ export declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKe
  * @param queue - The queue to get the tree for
  * @returns The tree for the given queue, or undefined if not found
  */
-export declare function getTreeForQueue(info: ActiveTreeBundle[], queue: PublicKey): PublicKey;
-/**
- * Get a random tree and queue from the active state tree addresses.
- *
- * Prevents write lock contention on state trees.
- *
- * @param info - The active state tree addresses
- * @returns A random tree and queue
- */
-export declare function pickRandomTreeAndQueue(info: ActiveTreeBundle[]): {
-    tree: PublicKey;
-    queue: PublicKey;
-};
+export declare function getTreeForQueue(info: StateTreeInfo[], queue: PublicKey): PublicKey;
 /**
  *
  */
 export declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    activeStateTreeInfo: ActiveTreeBundle[] | null;
+    allStateTreeInfos: StateTreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    CACHE_TTL: number;
+    fetchPromise: Promise<StateTreeInfo[]> | null;
     constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
     /**
-     * Manually set state tree addresses
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    setStateTreeInfo(info: ActiveTreeBundle[]): void;
+    getCachedActiveStateTreeInfos(): Promise<void>;
     /**
-     * Get the active state tree addresses from the cluster.
-     * If not already cached, fetches from the cluster.
+     * Get a list of all state tree infos. If not already cached, fetches from
+     * the cluster.
      */
-    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getStateTreeInfos(): Promise<StateTreeInfo[]>;
     /**
-     * Fetch the latest state tree addresses from the cluster.
+     * @internal
      */
-    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    doFetch(): Promise<StateTreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -265,12 +247,10 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * @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.
@@ -284,7 +264,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    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
@@ -299,7 +279,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of { address: BN254, tree: PublicKey, queue: PublicKey }.
      * @returns             validity proof with context
      */
-    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): 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
@@ -316,5 +296,5 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      *                      state tree/queue.
      * @returns             validity proof with context
      */
-    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
 }

package/dist/cjs/node/state/BN254.d.ts

@@ -7,7 +7,6 @@ import { Buffer } from 'buffer';
  * are used to from working with the web3.js PublicKey type.
  */
 export type BN254 = BN;
-export declare const bn: (number: string | number | BN | Buffer | Uint8Array | number[], base?: number | "hex" | undefined, endian?: BN.Endianness | undefined) => 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.  */

package/dist/cjs/node/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/cjs/node/state/compressed-account.d.ts

@@ -1,31 +1,71 @@
-import BN from 'bn.js';
 import { PublicKey } from '@solana/web3.js';
-import { CompressedAccount, CompressedAccountData } from './types';
+import { CompressedAccount, CompressedAccountData, StateTreeInfo } from './types';
+import BN from 'bn.js';
 import { BN254 } from './BN254';
 export type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext & {
     readOnly: boolean;
 };
 /**
- * Context for compressed account inserted into a state Merkle tree
- * */
-export type MerkleContext = {
-    /** State Merkle tree */
+ * @deprecated use {@link MerkleContext} instead.
+ *
+ * Legacy MerkleContext
+ */
+export type MerkleContextLegacy = {
+    /**
+     * State tree
+     */
     merkleTree: PublicKey;
-    /** The state nullfier queue belonging to merkleTree */
+    /**
+     * Nullifier queue
+     */
     nullifierQueue: PublicKey;
-    /** Poseidon hash of the utxo preimage. Is a leaf in state merkle tree  */
+    /**
+     * Poseidon hash of the account. Stored as leaf in state tree
+     */
     hash: number[];
-    /** 'hash' position within the Merkle tree */
+    /**
+     * Position of `hash` in the State tree
+     */
+    leafIndex: number;
+};
+/**
+ * Context for compressed account stored in a state tree
+ */
+export type MerkleContext = {
+    /**
+     * Tree info
+     */
+    treeInfo: StateTreeInfo;
+    /**
+     * 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 */
+    /**
+     * Recent valid 'hash' proof path, expires after n slots
+     */
     merkleProof: BN254[];
-    /** Index of state root the merkleproof is valid for, expires after n slots */
+    /**
+     * Index of state root the merkleproof is valid for, expires after n slots
+     */
     rootIndex: number;
-    /** Current root */
+    /**
+     * Current root
+     */
     root: BN254;
 };
 export declare const createCompressedAccount: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccount;
 export declare const createCompressedAccountWithMerkleContext: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: number[]) => CompressedAccountWithMerkleContext;
-export declare const createMerkleContext: (merkleTree: PublicKey, nullifierQueue: PublicKey, hash: number[], leafIndex: number) => MerkleContext;
+export declare const createMerkleContext: (treeInfo: StateTreeInfo, hash: BN254, leafIndex: number, proveByIndex?: boolean) => MerkleContext;

package/dist/cjs/node/state/index.d.ts

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

package/dist/cjs/node/state/types.d.ts

@@ -6,26 +6,79 @@ export declare enum TreeType {
     /**
      * v1 state merkle tree
      */
-    State = 0,
+    StateV1 = 1,
     /**
      * v1 address merkle tree
      */
-    Address = 1,
+    AddressV1 = 2,
     /**
      * v2 state merkle tree
      */
-    BatchedState = 2,
+    StateV2 = 3,
     /**
      * v2 address merkle tree
      */
-    BatchedAddress = 3
+    AddressV2 = 4
 }
+/**
+ * @deprecated Use {@link StateTreeInfo} instead.
+ *
+ * A bundle of active trees for a given tree type.
+ */
 export type ActiveTreeBundle = {
     tree: PublicKey;
     queue: PublicKey | null;
     cpiContext: PublicKey | null;
     treeType: TreeType;
 };
+/**
+ * State tree info, versioned via {@link TreeType}. The protocol
+ * stores compressed accounts in state trees.
+ *
+ * Onchain Accounts are subject to Solana's write-lock limits.
+ *
+ * To load balance transactions, use {@link selectStateTreeInfo} to
+ * select a random tree from a range of active trees.
+ *
+ * Example:
+ * ```typescript
+ * const infos = await rpc.getStateTreeInfos();
+ * const info = selectStateTreeInfo(infos);
+ * const ix = await CompressedTokenProgram.compress({
+ *     // ...
+ *     outputStateTreeInfo: info
+ * });
+ * ```
+ */
+export type StateTreeInfo = {
+    /**
+     * Pubkey of the tree account.
+     */
+    tree: PublicKey;
+    /**
+     * Pubkey of the queue account associated with the tree.
+     */
+    queue: PublicKey;
+    /**
+     * The type of tree. One of {@link TreeType}.
+     */
+    treeType: TreeType;
+    /**
+     * Optional compressed cpi context account.
+     */
+    cpiContext?: PublicKey;
+    /**
+     * Optional next tree info if the tree is full.
+     */
+    nextTreeInfo: StateTreeInfo | null;
+};
+/**
+ * Address tree info, versioned via {@link TreeType}. The protocol
+ * stores PDAs in address trees.
+ */
+export type AddressTreeInfo = Omit<StateTreeInfo, 'cpiContext' | 'nextTreeInfo'> & {
+    nextTreeInfo: AddressTreeInfo | null;
+};
 export interface PackedCompressedAccountWithMerkleContext {
     compressedAccount: CompressedAccount;
     merkleContext: PackedMerkleContext;
@@ -47,22 +100,27 @@ export interface QueueIndex {
  * compressed account.
  * */
 export interface CompressedAccount {
-    /** Public key of program or user that owns the account */
+    /**
+     * Public key of program or user owning the account.
+     */
     owner: PublicKey;
-    /** Lamports attached to the account */
+    /**
+     * Lamports attached to the account.
+     */
     lamports: BN;
     /**
-     * TODO: use PublicKey. Optional unique account ID that is persistent across
-     * transactions.
+     * Optional unique account ID that is persistent across transactions.
      */
     address: number[] | null;
-    /** Optional data attached to the account */
+    /**
+     * Optional data attached to the account.
+     */
     data: CompressedAccountData | null;
 }
 /**
  * Describe the generic compressed account details applicable to every
  * compressed account.
- * */
+ */
 export interface OutputCompressedAccountWithPackedContext {
     compressedAccount: CompressedAccount;
     merkleTreeIndex: number;
@@ -89,7 +147,7 @@ export interface PublicTransactionEvent {
     message: Uint8Array | null;
 }
 export interface InstructionDataInvoke {
-    proof: CompressedProof | null;
+    proof: ValidityProof | null;
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     relayFee: BN | null;
@@ -98,7 +156,7 @@ export interface InstructionDataInvoke {
     isCompress: boolean;
 }
 export interface InstructionDataInvokeCpi {
-    proof: CompressedProof | null;
+    proof: ValidityProof | null;
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
     relayFee: BN | null;
@@ -112,11 +170,28 @@ export interface CompressedCpiContext {
     first_set_context: boolean;
     cpi_context_account_index: number;
 }
+/**
+ * @deprecated Use {@link ValidityProof} instead.
+ */
 export interface CompressedProof {
     a: number[];
     b: number[];
     c: number[];
 }
+/**
+ * Validity proof.
+ *
+ * You can request proofs via `rpc.getValidityProof` or
+ * `rpc.getValidityProofV0`.
+ *
+ * One proof is 128 bytes large, and can prove the existence of N compressed
+ * accounts or the uniqueness of N PDAs.
+ */
+export interface ValidityProof {
+    a: number[];
+    b: number[];
+    c: number[];
+}
 export interface InputTokenDataWithContext {
     amount: BN;
     delegateIndex: number | null;

package/dist/cjs/node/test-helpers/test-rpc/get-compressed-accounts.d.ts

@@ -1,7 +1,16 @@
 import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Rpc } from '../../rpc';
-import { CompressedAccountWithMerkleContext } from '../../state';
+import { CompressedAccountWithMerkleContext, StateTreeInfo } from '../../state';
+/**
+ * Get the info for a given tree or queue
+ *
+ * @param info          The active state tree addresses
+ * @param treeOrQueue   The tree or queue to get the info for
+ * @returns The info for the given tree or queue, or throws an error if not
+ * found
+ */
+export declare function getStateTreeInfoByPubkey(treeInfos: StateTreeInfo[], treeOrQueue: PublicKey): StateTreeInfo;
 export declare function getCompressedAccountsByOwnerTest(rpc: Rpc, owner: PublicKey): Promise<CompressedAccountWithMerkleContext[]>;
 export declare function getCompressedAccountByHashTest(rpc: Rpc, hash: BN): Promise<CompressedAccountWithMerkleContext | undefined>;
 export declare function getMultipleCompressedAccountsByHashTest(rpc: Rpc, hashes: BN[]): Promise<CompressedAccountWithMerkleContext[]>;

package/dist/cjs/node/test-helpers/test-rpc/get-compressed-token-accounts.d.ts

@@ -32,7 +32,7 @@ export declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAcc
  * @param owner     PublicKey of the token owner
  * @param mint      PublicKey of the token mint
  */
-export declare function getCompressedTokenAccounts(events: PublicTransactionEvent[]): Promise<ParsedTokenAccount[]>;
+export declare function getCompressedTokenAccounts(events: PublicTransactionEvent[], rpc: Rpc): Promise<ParsedTokenAccount[]>;
 /** @internal */
 export declare function getCompressedTokenAccountsByOwnerTest(rpc: Rpc, owner: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
 export declare function getCompressedTokenAccountsByDelegateTest(rpc: Rpc, delegate: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;

package/dist/cjs/node/test-helpers/test-rpc/test-rpc.d.ts

@@ -1,10 +1,10 @@
 import { Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { AddressWithTree, CompressedMintTokenHolders, CompressedTransaction, GetCompressedAccountsByOwnerConfig, PaginatedOptions, HashWithTree, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, SignatureWithMetadata, WithContext, WithCursor } from '../../rpc-interface';
-import { CompressedProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
+import { ValidityProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
 import { BN254, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof } from '../../state';
 import { MerkleContextWithNewAddressProof } from '../../rpc';
-import { ActiveTreeBundle } from '../../state/types';
+import { StateTreeInfo } from '../../state/types';
 export interface TestRpcConfig {
     /**
      * Address of the state tree to index. Default: public default test state
@@ -55,7 +55,7 @@ export interface LightWasm {
  * @param depth                   Depth of the merkle tree.
  * @param log                     Log proof generation time.
  */
-export declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, merkleTreeAddress?: PublicKey, nullifierQueueAddress?: PublicKey, depth?: number, log?: boolean): Promise<TestRpc>;
+export declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, depth?: number, log?: boolean): Promise<TestRpc>;
 /**
  * Simple mock rpc for unit tests that simulates the compression rpc interface.
  * Fetches, parses events and builds merkletree on-demand, i.e. it does not persist state.
@@ -68,14 +68,13 @@ export declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, comp
 export declare class TestRpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    merkleTreeAddress: PublicKey;
-    nullifierQueueAddress: PublicKey;
-    addressTreeAddress: PublicKey;
-    addressQueueAddress: PublicKey;
     lightWasm: LightWasm;
     depth: number;
     log: boolean;
-    activeStateTreeInfo: ActiveTreeBundle[] | null;
+    allStateTreeInfos: StateTreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    fetchPromise: Promise<StateTreeInfo[]> | null;
+    CACHE_TTL: number;
     /**
      * Establish a Compression-compatible JSON RPC mock-connection
      *
@@ -90,17 +89,14 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      */
     constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
     /**
-     * Manually set state tree addresses
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    setStateTreeInfo(info: ActiveTreeBundle[]): void;
+    getCachedActiveStateTreeInfos(): Promise<void>;
     /**
      * Returns local test state trees.
      */
-    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
-    /**
-     * Returns local test state trees.
-     */
-    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getStateTreeInfos(): Promise<StateTreeInfo[]>;
+    doFetch(): Promise<StateTreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -238,12 +234,12 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      * Note: Use RPC class for forested trees. TestRpc is only for custom
      * testing purposes.
      */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     /**
      * @deprecated This method is not available for TestRpc. Please use
      * {@link getValidityProof} instead.
      */
-    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -258,6 +254,6 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
-    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
 }

package/dist/cjs/node/utils/get-state-tree-infos.d.ts

@@ -0,0 +1,41 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { StateTreeInfo, TreeType } from '../state/types';
+import { StateTreeLUTPair } from '../constants';
+/**
+ * @deprecated use {@link selectStateTreeInfo} instead.
+ *
+ * Get a random tree and queue from a set of provided state tree infos.
+ *
+ * @param infos Set of state tree infos
+ * @returns A random tree and queue
+ */
+export declare function pickRandomTreeAndQueue(infos: StateTreeInfo[]): {
+    tree: PublicKey;
+    queue: PublicKey;
+};
+/**
+ * Get a pseudo-random active state tree info from the set of provided state
+ * tree infos.
+ *
+ * Using this mitigates write lock contention on state trees.
+ *
+ * @param infos                 Set of state tree infos
+ * @param treeType              The type of tree. Defaults to `TreeType.StateV1`
+ * @param useMaxConcurrency     If true, return all infos. If false, return at
+ *                              most {@link MAX_HOTSPOTS}. Defaults to `false`.
+ *
+ * @returns A pseudo-randomly selected tree info
+ */
+export declare function selectStateTreeInfo(infos: StateTreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): StateTreeInfo;
+/**
+ * Get active state tree infos from LUTs.
+ *
+ * @param connection            The connection to the cluster
+ * @param stateTreeLUTPairs     The state tree lookup table pairs
+ *
+ * @returns The active state tree infos
+ */
+export declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
+    connection: Connection;
+    stateTreeLUTPairs: StateTreeLUTPair[];
+}): Promise<StateTreeInfo[]>;

package/dist/cjs/node/utils/index.d.ts

@@ -1,10 +1,13 @@
 export * from './address';
 export * from './airdrop';
+export * from './calculate-compute-unit-price';
 export * from './conversion';
+export * from './dedupe-signer';
+export * from './get-state-tree-infos';
 export * from './parse-validity-proof';
 export * from './pipe';
 export * from './send-and-confirm';
 export * from './sleep';
+export * from './state-tree-lookup-table';
 export * from './validation';
-export * from './calculate-compute-unit-price';
-export * from './get-light-state-tree-info';
+export * from './get-state-tree-infos';

package/dist/cjs/node/utils/parse-validity-proof.d.ts

@@ -1,4 +1,4 @@
-import { CompressedProof } from '../state';
+import { ValidityProof } from '../state';
 interface GnarkProofJson {
     ar: string[];
     bs: string[][];
@@ -14,7 +14,7 @@ export declare const placeholderValidityProof: () => {
     b: number[];
     c: number[];
 };
-export declare const checkValidityProofShape: (proof: CompressedProof) => void;
+export declare const checkValidityProofShape: (proof: ValidityProof) => void;
 export declare function proofFromJsonStruct(json: GnarkProofJson): ProofABC;
-export declare function negateAndCompressProof(proof: ProofABC): CompressedProof;
+export declare function negateAndCompressProof(proof: ProofABC): ValidityProof;
 export {};

package/dist/cjs/node/utils/state-tree-lookup-table.d.ts

@@ -0,0 +1,68 @@
+import { PublicKey, Keypair, Connection } from '@solana/web3.js';
+/**
+ * Create two lookup tables storing all public state tree and queue addresses
+ * returns lookup table addresses and txId
+ *
+ * @internal
+ * @param connection    Connection to the Solana network
+ * @param payer         Keypair of the payer
+ * @param authority     Keypair of the authority
+ * @param recentSlot    Slot of the recent block
+ */
+export declare function createStateTreeLookupTable({ connection, payer, authority, recentSlot, }: {
+    connection: Connection;
+    payer: Keypair;
+    authority: Keypair;
+    recentSlot: number;
+}): Promise<{
+    address: PublicKey;
+    txId: string;
+}>;
+/**
+ * Extend state tree lookup table with new state tree and queue addresses
+ *
+ * @internal
+ * @param connection                Connection to the Solana network
+ * @param tableAddress              Address of the lookup table to extend
+ * @param newStateTreeAddresses     Addresses of the new state trees to add
+ * @param newQueueAddresses         Addresses of the new queues to add
+ * @param newCpiContextAddresses    Addresses of the new cpi contexts to add
+ * @param payer                     Keypair of the payer
+ * @param authority                 Keypair of the authority
+ */
+export declare function extendStateTreeLookupTable({ connection, tableAddress, newStateTreeAddresses, newQueueAddresses, newCpiContextAddresses, payer, authority, }: {
+    connection: Connection;
+    tableAddress: PublicKey;
+    newStateTreeAddresses: PublicKey[];
+    newQueueAddresses: PublicKey[];
+    newCpiContextAddresses: PublicKey[];
+    payer: Keypair;
+    authority: Keypair;
+}): Promise<{
+    tableAddress: PublicKey;
+    txId: string;
+}>;
+/**
+ * Adds state tree address to lookup table. Acts as nullifier lookup for rolled
+ * over state trees.
+ *
+ * @internal
+ * @param connection                    Connection to the Solana network
+ * @param stateTreeAddress              Address of the state tree to nullify
+ * @param nullifyLookupTableAddress     Address of the nullifier lookup table to
+ *                                      store address in
+ * @param stateTreeLookupTableAddress   lookup table storing all state tree
+ *                                      addresses
+ * @param payer                         Keypair of the payer
+ * @param authority                     Keypair of the authority
+ */
+export declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyLookupTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
+    connection: Connection;
+    fullStateTreeAddress: PublicKey;
+    nullifyLookupTableAddress: PublicKey;
+    stateTreeLookupTableAddress: PublicKey;
+    payer: Keypair;
+    authority: Keypair;
+}): Promise<{
+    txId: string;
+}>;