@lightprotocol/stateless.js 0.21.0 → 0.22.0

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

@@ -4,7 +4,7 @@ import { ValidityProofWithContext, CompressedTransaction, CompressionApiInterfac
 import { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext, ValidityProof, AddressTreeInfo } from './state';
 import BN from 'bn.js';
 import { LightWasm } from './test-helpers';
-import { StateTreeInfo } 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<ValidityProof>;
+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;
@@ -68,25 +68,25 @@ 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 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: StateTreeInfo[], queue: PublicKey): PublicKey;
+export interface NullifierMetadata {
+    nullifier: BN254;
+    txHash: BN254;
+}
 /**
  *
  */
 export declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
-    allStateTreeInfos: StateTreeInfo[] | null;
+    allStateTreeInfos: TreeInfo[] | null;
     lastStateTreeFetchTime: number | null;
     CACHE_TTL: number;
-    fetchPromise: Promise<StateTreeInfo[]> | null;
+    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
      */
@@ -95,11 +95,11 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * Get a list of all state tree infos. If not already cached, fetches from
      * the cluster.
      */
-    getStateTreeInfos(): Promise<StateTreeInfo[]>;
+    getStateTreeInfos(): Promise<TreeInfo[]>;
     /**
      * @internal
      */
-    doFetch(): Promise<StateTreeInfo[]>;
+    doFetch(): Promise<TreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -228,26 +228,6 @@ 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<ValidityProofWithContext>;
     /**
      * @deprecated use {@link getValidityProofV0} instead.
      *

package/dist/cjs/node/state/compressed-account.d.ts

@@ -1,14 +1,48 @@
 import { PublicKey } from '@solana/web3.js';
-import { CompressedAccount, CompressedAccountData, StateTreeInfo } 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;
 };
+/**
+ * @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
+ * Legacy MerkleContext.
  */
 export type MerkleContextLegacy = {
     /**
@@ -35,7 +69,7 @@ export type MerkleContext = {
     /**
      * Tree info
      */
-    treeInfo: StateTreeInfo;
+    treeInfo: TreeInfo;
     /**
      * Poseidon hash of the account. Stored as leaf in state tree
      */
@@ -66,6 +100,106 @@ export type MerkleContextWithMerkleProof = MerkleContext & {
      */
     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: (treeInfo: StateTreeInfo, hash: BN254, leafIndex: number, proveByIndex?: boolean) => 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/types.d.ts

@@ -2,6 +2,7 @@ import BN from 'bn.js';
 import { PublicKey } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { NewAddressParamsPacked } from '../utils';
+import { PackedCompressedAccountWithMerkleContext } from './compressed-account';
 export declare enum TreeType {
     /**
      * v1 state merkle tree
@@ -21,24 +22,43 @@ export declare enum TreeType {
     AddressV2 = 4
 }
 /**
- * @deprecated Use {@link StateTreeInfo} instead.
+ * @deprecated Use {@link TreeInfo} instead.
  *
  * A bundle of active trees for a given tree type.
  */
 export type ActiveTreeBundle = {
+    /**
+     * Tree.
+     */
     tree: PublicKey;
+    /**
+     * Queue.
+     */
     queue: PublicKey | null;
+    /**
+     * CPI context.
+     */
     cpiContext: PublicKey | null;
+    /**
+     * Tree type.
+     */
     treeType: TreeType;
 };
 /**
+ * @deprecated Use {@link TreeInfo} instead.
+ *
  * State tree info, versioned via {@link TreeType}. The protocol
  * stores compressed accounts in state trees.
+ */
+export type StateTreeInfo = TreeInfo;
+/**
+ * Tree info, versioned via {@link TreeType}. The protocol
+ * stores compressed accounts in state trees, and PDAs in address 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.
+ * randomly select a tree from a range of active trees.
  *
  * Example:
  * ```typescript
@@ -50,7 +70,7 @@ export type ActiveTreeBundle = {
  * });
  * ```
  */
-export type StateTreeInfo = {
+export type TreeInfo = {
     /**
      * Pubkey of the tree account.
      */
@@ -68,38 +88,52 @@ export type StateTreeInfo = {
      */
     cpiContext?: PublicKey;
     /**
-     * Optional next tree info if the tree is full.
+     * Next tree info. Is `some` if the next tree should be used for the next
+     * state transition.
      */
-    nextTreeInfo: StateTreeInfo | null;
+    nextTreeInfo: TreeInfo | null;
 };
 /**
+ * @deprecated Use {@link TreeInfo} instead.
+ *
  * Address tree info, versioned via {@link TreeType}. The protocol
  * stores PDAs in address trees.
  */
 export type AddressTreeInfo = Omit<StateTreeInfo, 'cpiContext' | 'nextTreeInfo'> & {
+    /**
+     * Next tree info.
+     */
     nextTreeInfo: AddressTreeInfo | null;
 };
-export interface PackedCompressedAccountWithMerkleContext {
-    compressedAccount: CompressedAccount;
-    merkleContext: PackedMerkleContext;
-    rootIndex: number;
-    readOnly: boolean;
-}
-export interface PackedMerkleContext {
+/**
+ * Packed merkle context.
+ */
+export interface PackedMerkleContextLegacy {
+    /**
+     * Merkle tree pubkey index.
+     */
     merkleTreePubkeyIndex: number;
-    nullifierQueuePubkeyIndex: number;
+    /**
+     * Queue pubkey index in remaining accounts.
+     */
+    queuePubkeyIndex: number;
+    /**
+     * Leaf index.
+     */
     leafIndex: number;
-    queueIndex: null | QueueIndex;
-}
-export interface QueueIndex {
-    queueId: number;
-    index: number;
+    /**
+     * Whether to prove by index or validity proof.
+     */
+    proveByIndex: boolean;
 }
 /**
+ * @deprecated Use {@link CompressedAccount} instead.
+ *
  * Describe the generic compressed account details applicable to every
  * compressed account.
+ *
  * */
-export interface CompressedAccount {
+export interface CompressedAccountLegacy {
     /**
      * Public key of program or user owning the account.
      */
@@ -118,64 +152,217 @@ export interface CompressedAccount {
     data: CompressedAccountData | null;
 }
 /**
+ * @deprecated Use {@link CompressedAccountMeta} instead.
+ *
  * Describe the generic compressed account details applicable to every
  * compressed account.
  */
 export interface OutputCompressedAccountWithPackedContext {
-    compressedAccount: CompressedAccount;
+    compressedAccount: CompressedAccountLegacy;
     merkleTreeIndex: number;
 }
+/**
+ * Compressed account-related proof metadata.
+ */
+export type AccountProofInput = {
+    hash: BN;
+    treeInfo: TreeInfo;
+    leafIndex: number;
+    rootIndex: number;
+    proveByIndex: boolean;
+};
+/**
+ * New address proof metadata.
+ */
+export type NewAddressProofInput = {
+    treeInfo: TreeInfo;
+    address: number[];
+    rootIndex: number;
+    root: BN;
+};
+/**
+ * Describes compressed account data.
+ */
 export interface CompressedAccountData {
+    /**
+     * 8 bytes.
+     */
     discriminator: number[];
+    /**
+     * Data.
+     */
     data: Buffer;
+    /**
+     * 32 bytes.
+     */
     dataHash: number[];
 }
+/**
+ * Merkle tree sequence number.
+ */
 export interface MerkleTreeSequenceNumber {
+    /**
+     * Public key.
+     */
     pubkey: PublicKey;
+    /**
+     * Sequence number.
+     */
     seq: BN;
 }
+/**
+ * Public transaction event.
+ */
 export interface PublicTransactionEvent {
+    /**
+     * Input compressed account hashes.
+     */
     inputCompressedAccountHashes: number[][];
+    /**
+     * Output compressed account hashes.
+     */
     outputCompressedAccountHashes: number[][];
+    /**
+     * Output compressed accounts.
+     */
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Output leaf indices.
+     */
     outputLeafIndices: number[];
+    /**
+     * Sequence numbers.
+     */
     sequenceNumbers: MerkleTreeSequenceNumber[];
+    /**
+     * Relay fee. Default is null.
+     */
     relayFee: BN | null;
+    /**
+     * Whether it's a compress or decompress instruction.
+     */
     isCompress: boolean;
+    /**
+     * If some, it's either a compress or decompress instruction.
+     */
     compressOrDecompressLamports: BN | null;
+    /**
+     * Public keys.
+     */
     pubkeyArray: PublicKey[];
+    /**
+     * Message. Default is null.
+     */
     message: Uint8Array | null;
 }
+/**
+ * Instruction data for invoke.
+ */
 export interface InstructionDataInvoke {
+    /**
+     * Validity proof.
+     */
     proof: ValidityProof | null;
+    /**
+     * Input compressed accounts with merkle context.
+     */
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
+    /**
+     * Output compressed accounts.
+     */
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Relay fee. Default is null.
+     */
     relayFee: BN | null;
+    /**
+     * Params for creating new addresses.
+     */
     newAddressParams: NewAddressParamsPacked[];
+    /**
+     * If some, it's either a compress or decompress instruction.
+     */
     compressOrDecompressLamports: BN | null;
+    /**
+     * Whether it's a compress or decompress instruction.
+     */
     isCompress: boolean;
 }
+/**
+ * Instruction data for invoking a CPI.
+ */
 export interface InstructionDataInvokeCpi {
+    /**
+     * Validity proof.
+     */
     proof: ValidityProof | null;
+    /**
+     * Input compressed accounts with merkle context.
+     */
     inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
+    /**
+     * Output compressed accounts.
+     */
     outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    /**
+     * Relay fee. Default is null.
+     */
     relayFee: BN | null;
+    /**
+     * Params for creating new addresses.
+     */
     newAddressParams: NewAddressParamsPacked[];
+    /**
+     * If some, it's either a compress or decompress instruction.
+     */
     compressOrDecompressLamports: BN | null;
+    /**
+     * If `compressOrDecompressLamports` is some, whether it's a compress or
+     * decompress instruction.
+     */
     isCompress: boolean;
+    /**
+     * Optional compressed CPI context.
+     */
     compressedCpiContext: CompressedCpiContext | null;
 }
+/**
+ * Compressed CPI context.
+ *
+ * Use if you want to use a single {@link ValidityProof} to update two
+ * compressed accounts owned by separate programs.
+ */
 export interface CompressedCpiContext {
-    set_context: boolean;
-    first_set_context: boolean;
-    cpi_context_account_index: number;
+    /**
+     * Is set by the program that is invoking the CPI to signal that it should
+     * set the cpi context.
+     */
+    setContext: boolean;
+    /**
+     * Is set to wipe the cpi context since someone could have set it before
+     * with unrelated data.
+     */
+    firstSetContext: boolean;
+    /**
+     * Index of cpi context account in remaining accounts.
+     */
+    cpiContextAccountIndex: number;
 }
 /**
  * @deprecated Use {@link ValidityProof} instead.
  */
 export interface CompressedProof {
+    /**
+     * 32 bytes.
+     */
     a: number[];
+    /**
+     * 64 bytes.
+     */
     b: number[];
+    /**
+     * 32 bytes.
+     */
     c: number[];
 }
 /**
@@ -184,27 +371,79 @@ export interface CompressedProof {
  * 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.
+ * One proof can prove the existence of N compressed accounts or the uniqueness
+ * of N PDAs.
  */
 export interface ValidityProof {
+    /**
+     * 32 bytes.
+     */
     a: number[];
+    /**
+     * 64 bytes.
+     */
     b: number[];
+    /**
+     * 32 bytes.
+     */
     c: number[];
 }
+/**
+ * Packed token data for input compressed accounts.
+ */
 export interface InputTokenDataWithContext {
+    /**
+     * Amount of tokens.
+     */
     amount: BN;
+    /**
+     * Delegate index.
+     */
     delegateIndex: number | null;
-    merkleContext: PackedMerkleContext;
+    /**
+     * Merkle context.
+     */
+    merkleContext: PackedMerkleContextLegacy;
+    /**
+     * Root index.
+     */
     rootIndex: number;
+    /**
+     * Lamports.
+     */
     lamports: BN | null;
+    /**
+     * Tlv.
+     */
     tlv: Buffer | null;
 }
+/**
+ * Token data.
+ */
 export type TokenData = {
+    /**
+     * The mint associated with this account.
+     */
     mint: PublicKey;
+    /**
+     * The owner of this account.
+     */
     owner: PublicKey;
+    /**
+     * The amount of tokens this account holds.
+     */
     amount: BN;
+    /**
+     * If `delegate` is `Some` then `delegated_amount` represents the amount
+     * authorized by the delegate.
+     */
     delegate: PublicKey | null;
+    /**
+     * The account's state.
+     */
     state: number;
+    /**
+     * Token extension tlv.
+     */
     tlv: Buffer | null;
 };