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

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;
 };

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

@@ -1,16 +1,7 @@
 import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Rpc } from '../../rpc';
-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;
+import { CompressedAccountWithMerkleContext } from '../../state';
 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

@@ -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.
  *

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 { AccountInfo, 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 { ValidityProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
-import { BN254, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof } from '../../state';
+import { BN254, CompressedAccountWithMerkleContext, MerkleContext, MerkleContextWithMerkleProof } from '../../state';
 import { MerkleContextWithNewAddressProof } from '../../rpc';
-import { StateTreeInfo } 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 {
@@ -57,13 +39,13 @@ export interface LightWasm {
  */
 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;
@@ -71,9 +53,9 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
     lightWasm: LightWasm;
     depth: number;
     log: boolean;
-    allStateTreeInfos: StateTreeInfo[] | null;
+    allStateTreeInfos: TreeInfo[] | null;
     lastStateTreeFetchTime: number | null;
-    fetchPromise: Promise<StateTreeInfo[]> | null;
+    fetchPromise: Promise<TreeInfo[]> | null;
     CACHE_TTL: number;
     /**
      * Establish a Compression-compatible JSON RPC mock-connection
@@ -88,6 +70,10 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      * @param testRpcConfig             Config for the mock rpc
      */
     constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
+    /**
+     * @deprecated Use {@link getStateTreeInfos} instead
+     */
+    getCachedActiveStateTreeInfo(): Promise<void>;
     /**
      * @deprecated Use {@link getStateTreeInfos} instead
      */
@@ -95,8 +81,8 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
     /**
      * Returns local test state trees.
      */
-    getStateTreeInfos(): Promise<StateTreeInfo[]>;
-    doFetch(): Promise<StateTreeInfo[]>;
+    getStateTreeInfos(): Promise<TreeInfo[]>;
+    doFetch(): Promise<TreeInfo[]>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -184,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
@@ -225,16 +211,6 @@ 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<ValidityProofWithContext>;
     /**
      * @deprecated This method is not available for TestRpc. Please use
      * {@link getValidityProof} instead.
@@ -256,4 +232,8 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      */
     getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: TestRpc): Promise<{
+        accountInfo: AccountInfo<Buffer>;
+        merkleContext?: MerkleContext;
+    } | null>;
 }

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

@@ -1,6 +1,19 @@
 import { PublicKey } from '@solana/web3.js';
+/**
+ * Derive an address for a compressed account from a seed and an address Merkle
+ * tree public key.
+ *
+ * @param seed                     32 bytes seed to derive the address from
+ * @param addressMerkleTreePubkey  Address Merkle tree public key as bytes.
+ * @param programIdBytes           Program ID bytes.
+ * @returns                        Derived address as bytes
+ */
+export declare function deriveAddressV2(seed: Uint8Array, addressMerkleTreePubkey: Uint8Array, programIdBytes: Uint8Array): Uint8Array;
+export declare function hashVWithBumpSeed(bytes: Uint8Array[]): Uint8Array;
 export declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
 /**
+ * @deprecated Use {@link deriveAddressV2} instead, unless you're using v1.
+ *
  * Derive an address for a compressed account from a seed and an address Merkle
  * tree public key.
  *

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
@@ -21,6 +22,7 @@ export declare const toCamelCase: (object: any) => any;
  */
 export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number] | null;
 /**
+ * TODO: make consistent with latest rust. (use u8::max bumpseed)
  * Hash the provided `bytes` with Keccak256 and ensure that the result fits in
  * the BN254 prime field by truncating the resulting hash to 31 bytes.
  *
@@ -31,3 +33,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;