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

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

@@ -1,10 +1,10 @@
-import { Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
+import { AccountInfo, Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 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 { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext, ValidityProof, AddressTreeInfo, MerkleContext } 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;
@@ -12,7 +12,7 @@ export declare function parseAccountData({ discriminator, data, dataHash, }: {
     dataHash: BN;
 }): {
     discriminator: number[];
-    data: Buffer;
+    data: Buffer<ArrayBuffer>;
     dataHash: number[];
 };
 /**
@@ -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.
      *
@@ -297,4 +277,18 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @returns             validity proof with context
      */
     getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
+    /**
+     * Get account info from either compressed or onchain storage.
+     * @param address         The account address to fetch.
+     * @param programId       The owner program ID.
+     * @param addressTreeInfo The address tree info used to store the account.
+     * @param rpc             The RPC client to use.
+     *
+     * @returns               Account info with compression info, or null if account
+     *                        doesn't exist.
+     */
+    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: Rpc): Promise<{
+        accountInfo: AccountInfo<Buffer>;
+        merkleContext?: MerkleContext;
+    } | null>;
 }

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;