@lightprotocol/stateless.js 0.20.9 → 0.22.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 { TreeInfo } 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,55 +68,38 @@ 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
- *
- * @param info - The active state tree addresses
- * @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 interface NullifierMetadata {
+    nullifier: BN254;
+    txHash: BN254;
+}
 /**
  *
  */
 export declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    activeStateTreeInfo: ActiveTreeBundle[] | null;
+    allStateTreeInfos: TreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    CACHE_TTL: number;
+    fetchPromise: Promise<TreeInfo[]> | null;
     constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
     /**
-     * Manually set state tree addresses
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    setStateTreeInfo(info: ActiveTreeBundle[]): void;
+    getCachedActiveStateTreeInfo(): Promise<void>;
     /**
-     * Get the active state tree addresses from the cluster.
-     * If not already cached, fetches from the cluster.
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getCachedActiveStateTreeInfos(): Promise<void>;
     /**
-     * Fetch the latest state tree addresses from the cluster.
+     * Get a list of all state tree infos. If not already cached, fetches from
+     * the cluster.
      */
-    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getStateTreeInfos(): Promise<TreeInfo[]>;
+    /**
+     * @internal
+     */
+    doFetch(): Promise<TreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -246,31 +228,9 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @returns Array of validity proofs for new addresses
      */
     getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
-    /**
-     * Advanced usage of getValidityProof: fetches ZKP directly from a custom
-     * non-rpcprover. Note: This uses the proverEndpoint specified in the
-     * constructor. For normal usage, please use {@link getValidityProof}
-     * 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
-     */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
     /**
      * @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 +244,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 +259,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 +276,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,205 @@
-import BN from 'bn.js';
 import { PublicKey } from '@solana/web3.js';
-import { CompressedAccount, CompressedAccountData } from './types';
+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;
 };
 /**
- * Context for compressed account inserted into a state Merkle tree
- * */
-export type MerkleContext = {
-    /** State Merkle tree */
+ * @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;
-    /** 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: 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 */
+    /**
+     * 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;
+/**
+ * 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/cjs/node/state/index.d.ts

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