@lightprotocol/stateless.js 0.20.9 → 0.22.0

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

@@ -2,134 +2,448 @@ 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
      */
-    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 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;
 };
-export interface PackedCompressedAccountWithMerkleContext {
-    compressedAccount: CompressedAccount;
-    merkleContext: PackedMerkleContext;
-    rootIndex: number;
-    readOnly: boolean;
-}
-export interface PackedMerkleContext {
+/**
+ * @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
+ * randomly select a 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 TreeInfo = {
+    /**
+     * 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;
+    /**
+     * Next tree info. Is `some` if the next tree should be used for the next
+     * state transition.
+     */
+    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;
+};
+/**
+ * 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 {
-    /** Public key of program or user that owns the account */
+export interface CompressedAccountLegacy {
+    /**
+     * 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;
 }
 /**
+ * @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 {
-    proof: CompressedProof | null;
+    /**
+     * 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 {
-    proof: CompressedProof | null;
+    /**
+     * 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[];
 }
+/**
+ * Validity proof.
+ *
+ * You can request proofs via `rpc.getValidityProof` or
+ * `rpc.getValidityProofV0`.
+ *
+ * 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;
 };

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

@@ -2,7 +2,7 @@ import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Rpc } from '../../rpc';
 import { ParsedTokenAccount, WithCursor } from '../../rpc-interface';
-import { CompressedAccount, PublicTransactionEvent } from '../../state';
+import { PublicTransactionEvent, CompressedAccountLegacy } from '../../state';
 import { Layout } from '@coral-xyz/borsh';
 type TokenData = {
     mint: PublicKey;
@@ -22,7 +22,7 @@ export type EventWithParsedTokenTlvData = {
  * @param compressedAccount - The compressed account
  * @returns The parsed token data
  */
-export declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccount, programId?: PublicKey): TokenData | null;
+export declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccountLegacy, programId?: PublicKey): TokenData | null;
 /**
  * Retrieves all compressed token accounts for a given mint and owner.
  *
@@ -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,20 +1,11 @@
 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 { TreeInfo } from '../../state/types';
 export interface TestRpcConfig {
-    /**
-     * Address of the state tree to index. Default: public default test state
-     * tree.
-     */
-    merkleTreeAddress?: PublicKey;
-    /**
-     * Nullifier queue associated with merkleTreeAddress
-     */
-    nullifierQueueAddress?: PublicKey;
     /**
      * Depth of state tree. Defaults to the public default test state tree depth
      */
@@ -23,15 +14,6 @@ export interface TestRpcConfig {
      * Log proof generation time
      */
     log?: boolean;
-    /**
-     * Address of the address tree to index. Default: public default test
-     * address tree.
-     */
-    addressTreeAddress?: PublicKey;
-    /**
-     * Address queue associated with addressTreeAddress
-     */
-    addressQueueAddress?: PublicKey;
 }
 export type ClientSubscriptionId = number;
 export interface LightWasm {
@@ -55,27 +37,26 @@ 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.
+ * Mock RPC for unit tests that simulates the ZK Compression RPC interface.
+ * Parses events and builds merkletree on-demand. It does not persist state.
  * Constraints:
- * - Can only index 1 merkletree
  * - Can only index up to 1000 transactions
  *
- * For advanced testing use photon: https://github.com/helius-labs/photon
+ * For advanced testing use `Rpc` class which uses photon:
+ * https://github.com/helius-labs/photon
  */
 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: TreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    fetchPromise: Promise<TreeInfo[]> | null;
+    CACHE_TTL: number;
     /**
      * Establish a Compression-compatible JSON RPC mock-connection
      *
@@ -90,17 +71,18 @@ 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;
+    getCachedActiveStateTreeInfo(): Promise<void>;
     /**
-     * Returns local test state trees.
+     * @deprecated Use {@link getStateTreeInfos} instead
      */
-    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getCachedActiveStateTreeInfos(): Promise<void>;
     /**
      * Returns local test state trees.
      */
-    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    getStateTreeInfos(): Promise<TreeInfo[]>;
+    doFetch(): Promise<TreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -188,7 +170,7 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      * Fetch a confirmed or finalized transaction from the cluster. Return with
      * CompressionInfo
      */
-    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction | null>;
+    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction>;
     /**
      * Returns confirmed signatures for transactions involving the specified
      * address forward in time from genesis to the most recent confirmed
@@ -229,21 +211,11 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      */
     getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
     getCompressedMintTokenHolders(_mint: PublicKey, _options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
-    /**
-     * 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.
-     *
-     * Note: Use RPC class for forested trees. TestRpc is only for custom
-     * testing purposes.
-     */
-    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
     /**
      * @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 +230,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/calculate-compute-unit-price.d.ts

@@ -2,6 +2,6 @@
  * @param targetLamports - Target priority fee in lamports
  * @param computeUnits - Expected compute units used by the transaction
  * @returns microLamports per compute unit (use in
- * `ComputeBudgetProgram.setComputeUnitPrice`)
+ * {@link https://github.com/solana-foundation/solana-web3.js/blob/maintenance/v1.x/src/programs/compute-budget.ts#L218})
  */
 export declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;

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

@@ -1,6 +1,7 @@
 import { Buffer } from 'buffer';
 import { Keypair } from '@solana/web3.js';
 import BN from 'bn.js';
+import { InstructionDataInvoke } from '../state';
 export declare function byteArrayToKeypair(byteArray: number[]): Keypair;
 /**
  * @internal
@@ -31,3 +32,4 @@ export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number]
 export declare function hashvToBn254FieldSizeBe(bytes: Uint8Array[]): Uint8Array;
 /** Mutates array in place */
 export declare function pushUniqueItems<T>(items: T[], map: T[]): void;
+export declare function convertInvokeCpiWithReadOnlyToInvoke(data: any): InstructionDataInvoke;