@lightprotocol/stateless.js 0.18.0 → 0.20.0

package/dist/cjs/node/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/node/rpc-interface.d.ts

@@ -165,24 +165,24 @@ export declare function jsonRpcResultAndContext<T, U>(value: Struct<T, U>): Stru
 export declare const CompressedAccountResult: Struct<{
     data: {
         data: string;
-        discriminator: BN;
         dataHash: BN;
+        discriminator: BN;
     } | null;
-    owner: PublicKey;
     lamports: BN;
     address: number[] | null;
-    leafIndex: number;
-    seq: BN | null;
     hash: BN;
+    owner: PublicKey;
+    leafIndex: number;
     tree: PublicKey;
+    seq: BN | null;
     slotCreated: BN;
 }, {
     address: Struct<number[] | null, null>;
     hash: Struct<BN, null>;
     data: Struct<{
         data: string;
-        discriminator: BN;
         dataHash: BN;
+        discriminator: BN;
     } | null, {
         data: Struct<string, null>;
         dataHash: Struct<BN, null>;
@@ -222,16 +222,16 @@ export declare const CompressedTokenAccountResult: Struct<{
     account: {
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     };
 }, {
@@ -251,24 +251,24 @@ export declare const CompressedTokenAccountResult: Struct<{
     account: Struct<{
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
         data: Struct<{
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null, {
             data: Struct<string, null>;
             dataHash: Struct<BN, null>;
@@ -289,54 +289,54 @@ export declare const MultipleCompressedAccountsResult: Struct<{
     items: {
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }[];
 }, {
     items: Struct<{
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
         data: Struct<{
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null, {
             data: Struct<string, null>;
             dataHash: Struct<BN, null>;
@@ -357,16 +357,16 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
     items: {
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }[];
     cursor: string | null;
@@ -374,38 +374,38 @@ export declare const CompressedAccountsByOwnerResult: Struct<{
     items: Struct<{
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }[], Struct<{
         data: {
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null;
-        owner: PublicKey;
         lamports: BN;
         address: number[] | null;
-        leafIndex: number;
-        seq: BN | null;
         hash: BN;
+        owner: PublicKey;
+        leafIndex: number;
         tree: PublicKey;
+        seq: BN | null;
         slotCreated: BN;
     }, {
         address: Struct<number[] | null, null>;
         hash: Struct<BN, null>;
         data: Struct<{
             data: string;
-            discriminator: BN;
             dataHash: BN;
+            discriminator: BN;
         } | null, {
             data: Struct<string, null>;
             dataHash: Struct<BN, null>;
@@ -435,16 +435,16 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
         account: {
             data: {
                 data: string;
-                discriminator: BN;
                 dataHash: BN;
+                discriminator: BN;
             } | null;
-            owner: PublicKey;
             lamports: BN;
             address: number[] | null;
-            leafIndex: number;
-            seq: BN | null;
             hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
             tree: PublicKey;
+            seq: BN | null;
             slotCreated: BN;
         };
     }[];
@@ -461,16 +461,16 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
         account: {
             data: {
                 data: string;
-                discriminator: BN;
                 dataHash: BN;
+                discriminator: BN;
             } | null;
-            owner: PublicKey;
             lamports: BN;
             address: number[] | null;
-            leafIndex: number;
-            seq: BN | null;
             hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
             tree: PublicKey;
+            seq: BN | null;
             slotCreated: BN;
         };
     }[], Struct<{
@@ -484,16 +484,16 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
         account: {
             data: {
                 data: string;
-                discriminator: BN;
                 dataHash: BN;
+                discriminator: BN;
             } | null;
-            owner: PublicKey;
             lamports: BN;
             address: number[] | null;
-            leafIndex: number;
-            seq: BN | null;
             hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
             tree: PublicKey;
+            seq: BN | null;
             slotCreated: BN;
         };
     }, {
@@ -513,24 +513,24 @@ export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
         account: Struct<{
             data: {
                 data: string;
-                discriminator: BN;
                 dataHash: BN;
+                discriminator: BN;
             } | null;
-            owner: PublicKey;
             lamports: BN;
             address: number[] | null;
-            leafIndex: number;
-            seq: BN | null;
             hash: BN;
+            owner: PublicKey;
+            leafIndex: number;
             tree: PublicKey;
+            seq: BN | null;
             slotCreated: BN;
         }, {
             address: Struct<number[] | null, null>;
             hash: Struct<BN, null>;
             data: Struct<{
                 data: string;
-                discriminator: BN;
                 dataHash: BN;
+                discriminator: BN;
             } | null, {
                 data: Struct<string, null>;
                 dataHash: Struct<BN, null>;
@@ -613,10 +613,10 @@ export declare const LatestNonVotingSignaturesResultPaginated: Struct<{
  */
 export declare const MerkeProofResult: Struct<{
     root: BN;
-    proof: BN[];
-    leafIndex: number;
     hash: BN;
+    leafIndex: number;
     merkleTree: PublicKey;
+    proof: BN[];
     rootSeq: number;
 }, {
     hash: Struct<BN, null>;
@@ -631,9 +631,9 @@ export declare const MerkeProofResult: Struct<{
  */
 export declare const NewAddressProofResult: Struct<{
     root: BN;
-    proof: BN[];
     address: BN;
     merkleTree: PublicKey;
+    proof: BN[];
     rootSeq: number;
     nextIndex: number;
     lowerRangeAddress: BN;
@@ -685,17 +685,17 @@ export declare const ValidityProofResult: Struct<{
  */
 export declare const MultipleMerkleProofsResult: Struct<{
     root: BN;
-    proof: BN[];
-    leafIndex: number;
     hash: BN;
+    leafIndex: number;
     merkleTree: PublicKey;
+    proof: BN[];
     rootSeq: number;
 }[], Struct<{
     root: BN;
-    proof: BN[];
-    leafIndex: number;
     hash: BN;
+    leafIndex: number;
     merkleTree: PublicKey;
+    proof: BN[];
     rootSeq: number;
 }, {
     hash: Struct<BN, null>;
@@ -780,8 +780,8 @@ export declare const CompressedMintTokenHoldersResult: Struct<{
 }>;
 export declare const AccountProofResult: Struct<{
     root: number[];
-    proof: number[][];
     hash: number[];
+    proof: number[][];
 }, {
     hash: Struct<number[], Struct<number, null>>;
     root: Struct<number[], Struct<number, null>>;
@@ -838,16 +838,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -862,16 +862,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -890,16 +890,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -914,16 +914,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -939,16 +939,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -962,16 +962,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -985,24 +985,24 @@ export declare const CompressedTransactionResult: Struct<{
             account: Struct<{
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             }, {
                 address: Struct<number[] | null, null>;
                 hash: Struct<BN, null>;
                 data: Struct<{
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null, {
                     data: Struct<string, null>;
                     dataHash: Struct<BN, null>;
@@ -1033,16 +1033,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1056,16 +1056,16 @@ export declare const CompressedTransactionResult: Struct<{
             account: {
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             };
             optionalTokenData: {
@@ -1079,24 +1079,24 @@ export declare const CompressedTransactionResult: Struct<{
             account: Struct<{
                 data: {
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null;
-                owner: PublicKey;
                 lamports: BN;
                 address: number[] | null;
-                leafIndex: number;
-                seq: BN | null;
                 hash: BN;
+                owner: PublicKey;
+                leafIndex: number;
                 tree: PublicKey;
+                seq: BN | null;
                 slotCreated: BN;
             }, {
                 address: Struct<number[] | null, null>;
                 hash: Struct<BN, null>;
                 data: Struct<{
                     data: string;
-                    discriminator: BN;
                     dataHash: BN;
+                    discriminator: BN;
                 } | null, {
                     data: Struct<string, null>;
                     dataHash: Struct<BN, null>;

package/dist/cjs/node/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 { ActiveTreeBundle } from './state/types';
 /** @internal */
 export declare function parseAccountData({ discriminator, data, dataHash, }: {
     discriminator: BN;
@@ -60,23 +62,56 @@ 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: ActiveTreeBundle[], 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: ActiveTreeBundle[], 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: ActiveTreeBundle[]): {
+    tree: PublicKey;
+    queue: PublicKey;
+};
 /**
  *
  */
 export declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
+    activeStateTreeInfo: ActiveTreeBundle[] | 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: ActiveTreeBundle[]): void;
+    /**
+     * Get the active state tree addresses from the cluster.
+     * If not already cached, fetches from the cluster.
+     */
+    getCachedActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
+    /**
+     * Fetch the latest state tree addresses from the cluster.
+     */
+    getLatestActiveStateTreeInfo(): Promise<ActiveTreeBundle[]>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -226,6 +261,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.