@lightprotocol/stateless.js 0.18.0 → 0.19.0

package/dist/cjs/browser/instruction/pack-compressed-accounts.d.ts

@@ -6,7 +6,22 @@ import { CompressedAccountWithMerkleContext } from '../state/compressed-account'
  * present
  * */
 export declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): number;
-/** @internal */
+/**
+ * @internal
+ * Pads output state trees with the 0th state tree of the input state.
+ *
+ * @param outputStateMerkleTrees            Optional output state trees to be
+ *                                          inserted into the output state.
+ *                                          Defaults to the 0th state tree of
+ *                                          the input state. Gets padded to the
+ *                                          length of outputCompressedAccounts.
+ * @param numberOfOutputCompressedAccounts  The number of output compressed
+ *                                          accounts.
+ * @param inputCompressedAccountsWithMerkleContext The input compressed accounts
+ *                                          with merkle context.
+ *
+ * @returns Padded output state trees.
+ */
 export declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey[] | PublicKey | undefined, numberOfOutputCompressedAccounts: number, inputCompressedAccountsWithMerkleContext: CompressedAccountWithMerkleContext[]): PublicKey[];
 export declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
 /**
@@ -14,6 +29,7 @@ export declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountM
  *
  * Replaces PublicKey with index pointer to remaining accounts.
  *
+ *
  * @param inputCompressedAccounts           Ix input state to be consumed
  * @param inputStateRootIndices             The recent state root indices of the
  *                                          input state. The expiry is tied to

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

@@ -3,6 +3,8 @@ 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 BN from 'bn.js';
+import { LightWasm } from './test-helpers';
+import { ActiveStateTreeAddresses } from './utils/get-light-state-tree-info';
 /** @internal */
 export declare function parseAccountData({ discriminator, data, dataHash, }: {
     discriminator: BN;
@@ -60,23 +62,57 @@ export type NonInclusionJsonStruct = {
 };
 export declare function convertMerkleProofsWithContextToHex(merkleProofsWithContext: MerkleContextWithMerkleProof[]): HexInputsForProver[];
 export declare function convertNonInclusionMerkleProofInputsToHex(nonInclusionMerkleProofInputs: MerkleContextWithNewAddressProof[]): NonInclusionJsonStruct[];
-import { LightWasm } from './test-helpers';
 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: ActiveStateTreeAddresses, 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: ActiveStateTreeAddresses, 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: ActiveStateTreeAddresses): {
+    tree: PublicKey;
+    queue: PublicKey;
+};
 /**
  *
  */
 export declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
+    activeStateTreeInfo: ActiveStateTreeAddresses | null;
+    fetchStateTreePromise: Promise<ActiveStateTreeAddresses> | null;
+    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
     /**
-     * Establish a Compression-compatible JSON RPC connection
-     *
-     * @param endpoint                      Endpoint to the solana cluster
-     * @param compressionApiEndpoint        Endpoint to the compression server
-     * @param proverEndpoint                Endpoint to the prover server.
-     * @param connectionConfig              Optional connection config
+     * Manually set state tree addresses
      */
-    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
+    setStateTreeInfo(info: ActiveStateTreeAddresses): void;
+    /**
+     * Get the active state tree addresses from the cluster.
+     * If not already cached, fetches from the cluster.
+     */
+    getCachedActiveStateTreeInfo(): Promise<ActiveStateTreeAddresses>;
+    /**
+     * Fetch the latest state tree addresses from the cluster.
+     */
+    getLatestActiveStateTreeInfo(): Promise<ActiveStateTreeAddresses>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -226,6 +262,10 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      */
     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.

package/dist/cjs/browser/test-helpers/index.d.ts

@@ -1,2 +1,3 @@
 export * from './merkle-tree';
 export * from './test-rpc';
+export * from './test-utils';

package/dist/cjs/browser/test-helpers/test-rpc/test-rpc.d.ts

@@ -4,6 +4,7 @@ import { AddressWithTree, CompressedMintTokenHolders, CompressedTransaction, Get
 import { CompressedProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
 import { BN254, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof } from '../../state';
 import { MerkleContextWithNewAddressProof } from '../../rpc';
+import { ActiveStateTreeAddresses } from '../../utils/get-light-state-tree-info';
 export interface TestRpcConfig {
     /**
      * Address of the state tree to index. Default: public default test state
@@ -74,6 +75,8 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
     lightWasm: LightWasm;
     depth: number;
     log: boolean;
+    activeStateTreeInfo: ActiveStateTreeAddresses | null;
+    fetchStateTreePromise: Promise<ActiveStateTreeAddresses> | null;
     /**
      * Establish a Compression-compatible JSON RPC mock-connection
      *
@@ -87,6 +90,18 @@ 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);
+    /**
+     * Manually set state tree addresses
+     */
+    setStateTreeInfo(info: ActiveStateTreeAddresses): void;
+    /**
+     * Returns local test state trees.
+     */
+    getCachedActiveStateTreeInfo(): Promise<ActiveStateTreeAddresses>;
+    /**
+     * Returns local test state trees.
+     */
+    getLatestActiveStateTreeInfo(): Promise<ActiveStateTreeAddresses>;
     /**
      * Fetch the compressed account for the specified account hash
      */

package/dist/cjs/browser/utils/get-light-state-tree-info.d.ts

@@ -0,0 +1,74 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+/**
+ * Create two lookup tables storing all public state tree and queue addresses
+ * returns lookup table addresses and txId
+ *
+ * @internal
+ * @param connection - Connection to the Solana network
+ * @param payer - Keypair of the payer
+ * @param authority - Keypair of the authority
+ * @param recentSlot - Slot of the recent block
+ */
+export declare function createStateTreeLookupTable({ connection, payer, authority, recentSlot, }: {
+    connection: Connection;
+    payer: Keypair;
+    authority: Keypair;
+    recentSlot: number;
+}): Promise<{
+    address: PublicKey;
+    txId: string;
+}>;
+/**
+ * Extend state tree lookup table with new state tree and queue addresses
+ * @internal
+ * @param connection - Connection to the Solana network
+ * @param tableAddress - Address of the lookup table to extend
+ * @param newStateTreeAddresses - Addresses of the new state trees to add
+ * @param newQueueAddresses - Addresses of the new queues to add
+ * @param payer - Keypair of the payer
+ * @param authority - Keypair of the authority
+ */
+export declare function extendStateTreeLookupTable({ connection, tableAddress, newStateTreeAddresses, newQueueAddresses, payer, authority, }: {
+    connection: Connection;
+    tableAddress: PublicKey;
+    newStateTreeAddresses: PublicKey[];
+    newQueueAddresses: PublicKey[];
+    payer: Keypair;
+    authority: Keypair;
+}): Promise<{
+    tableAddress: PublicKey;
+    txId: string;
+}>;
+/**
+ * Adds full state tree address to lookup table. Acts as nullifier
+ * @internal
+ * @param connection - Connection to the Solana network
+ * @param stateTreeAddress - Address of the state tree to nullify
+ * @param nullifyTableAddress - Address nullifier lookup table to store address in
+ * @param stateTreeLookupTableAddress - lookup table storing all state tree addresses
+ * @param payer - Keypair of the payer
+ * @param authority - Keypair of the authority
+ */
+export declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
+    connection: Connection;
+    fullStateTreeAddress: PublicKey;
+    nullifyTableAddress: PublicKey;
+    stateTreeLookupTableAddress: PublicKey;
+    payer: Keypair;
+    authority: Keypair;
+}): Promise<{
+    txId: string;
+}>;
+export type ActiveStateTreeAddresses = {
+    activeStateTrees: PublicKey[];
+    activeQueues: PublicKey[];
+};
+/**
+ *  Get most recent , active state tree data
+ * we store in lookup table for each public state tree
+ */
+export declare function getLightStateTreeInfo({ connection, stateTreeLookupTableAddress, nullifyTableAddress, }: {
+    connection: Connection;
+    stateTreeLookupTableAddress: PublicKey;
+    nullifyTableAddress: PublicKey;
+}): Promise<ActiveStateTreeAddresses>;

package/dist/cjs/browser/utils/index.d.ts

@@ -5,6 +5,6 @@ export * from './parse-validity-proof';
 export * from './pipe';
 export * from './send-and-confirm';
 export * from './sleep';
-export * from './test-utils';
 export * from './validation';
 export * from './calculate-compute-unit-price';
+export * from './get-light-state-tree-info';

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

@@ -17,6 +17,21 @@ export declare const defaultStaticAccountsStruct: () => {
     accountCompressionAuthority: PublicKey;
     cpiSignatureAccount: null;
 };
+export declare const defaultStateTreeLookupTables: () => {
+    mainnet: {
+        stateTreeLookupTable: PublicKey;
+        nullifyTable: PublicKey;
+    };
+    devnet: {
+        stateTreeLookupTable: PublicKey;
+        nullifyTable: PublicKey;
+    };
+};
+export declare const isLocalTest: (url: string) => boolean;
+export declare const localTestActiveStateTreeInfo: () => {
+    activeStateTrees: PublicKey[];
+    activeQueues: PublicKey[];
+};
 export declare const defaultTestStateTreeAccounts: () => {
     nullifierQueue: PublicKey;
     merkleTree: PublicKey;
@@ -24,10 +39,20 @@ export declare const defaultTestStateTreeAccounts: () => {
     addressTree: PublicKey;
     addressQueue: PublicKey;
 };
+export declare const defaultTestStateTreeAccounts2: () => {
+    nullifierQueue2: PublicKey;
+    merkleTree2: PublicKey;
+};
+export declare const stateTreeLookupTableMainnet = "ABwZ1gQYCrj74azGZvtSk6eBQ9PD7Ch1FCcETcjr9QcC";
+export declare const nullifiedStateTreeLookupTableMainnet = "9cnE7YBEUQXDf7gbapCCnRR7cERYqac6ip1g1cfdF2nb";
+export declare const stateTreeLookupTableDevnet = "zpuJRGT84P9nMzTwpBihvWrRwazj8caUJTya8JAVQnv";
+export declare const nullifiedStateTreeLookupTableDevnet = "3rsYNhcaosPZcMrSiQubjbE3rTLuAYJQvSe78NCruqCB";
 export declare const nullifierQueuePubkey = "nfq1NvQDJ2GEgnS8zt9prAe8rjjpAW1zFkrvZoBR148";
 export declare const merkletreePubkey = "smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT";
 export declare const addressTree = "amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2";
 export declare const addressQueue = "aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F";
+export declare const merkleTree2Pubkey = "smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho";
+export declare const nullifierQueue2Pubkey = "nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X";
 export declare const confirmConfig: ConfirmOptions;
 export declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
 export declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;

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

@@ -1009,6 +1009,10 @@ export type LightSystemProgram = {
         {
             code: 6037;
             name: 'InvalidAddressTreeHeight';
+        },
+        {
+            code: 6038;
+            name: 'InvalidStateTreeHeight';
         }
     ];
 };