@lightprotocol/stateless.js 0.20.9 → 0.22.0

package/dist/cjs/node/utils/get-state-tree-infos.d.ts

@@ -0,0 +1,48 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { TreeInfo, TreeType } from '../state/types';
+import { StateTreeLUTPair } from '../constants';
+/**
+ * @deprecated use {@link getTreeInfoByPubkey} instead
+ */
+export declare function getStateTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
+export declare function getTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
+/**
+ * @deprecated use {@link selectStateTreeInfo} instead.
+ *
+ * Get a random tree and queue from a set of provided state tree infos.
+ *
+ * @param infos Set of state tree infos
+ * @returns A random tree and queue
+ */
+export declare function pickRandomTreeAndQueue(infos: TreeInfo[]): {
+    tree: PublicKey;
+    queue: PublicKey;
+};
+/**
+ * Select a pseudo-random active state tree info from the set of provided state
+ * tree infos.
+ *
+ * Using this reduces write-lock contention on state trees.
+ *
+ * @param infos                 Set of state tree infos
+ *
+ * @param treeType              Optional: Only use if you know what you are
+ *                              doing. The type of tree.
+ * @param useMaxConcurrency     Optional: Only use if you know what you are
+ *                              doing. If true, select from all infos.
+ *
+ * @returns A pseudo-randomly selected tree info
+ */
+export declare function selectStateTreeInfo(infos: TreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): TreeInfo;
+/**
+ * Get active state tree infos from LUTs.
+ *
+ * @param connection            The connection to the cluster
+ * @param stateTreeLUTPairs     The state tree lookup table pairs
+ *
+ * @returns The active state tree infos
+ */
+export declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
+    connection: Connection;
+    stateTreeLUTPairs: StateTreeLUTPair[];
+}): Promise<TreeInfo[]>;

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

@@ -1,10 +1,12 @@
 export * from './address';
 export * from './airdrop';
+export * from './calculate-compute-unit-price';
 export * from './conversion';
+export * from './dedupe-signer';
 export * from './parse-validity-proof';
 export * from './pipe';
 export * from './send-and-confirm';
 export * from './sleep';
 export * from './validation';
-export * from './calculate-compute-unit-price';
-export * from './get-light-state-tree-info';
+export * from './state-tree-lookup-table';
+export * from './get-state-tree-infos';

package/dist/cjs/node/utils/parse-validity-proof.d.ts

@@ -1,4 +1,4 @@
-import { CompressedProof } from '../state';
+import { ValidityProof } from '../state';
 interface GnarkProofJson {
     ar: string[];
     bs: string[][];
@@ -14,7 +14,7 @@ export declare const placeholderValidityProof: () => {
     b: number[];
     c: number[];
 };
-export declare const checkValidityProofShape: (proof: CompressedProof) => void;
+export declare const checkValidityProofShape: (proof: ValidityProof) => void;
 export declare function proofFromJsonStruct(json: GnarkProofJson): ProofABC;
-export declare function negateAndCompressProof(proof: ProofABC): CompressedProof;
+export declare function negateAndCompressProof(proof: ProofABC): ValidityProof;
 export {};

package/dist/cjs/node/utils/send-and-confirm.d.ts

@@ -34,7 +34,7 @@ export declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, con
  * @param blockHashCtx      blockhash context for confirmation
  * @return SignatureResult
  */
-export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, _blockHashCtx?: {
     blockhash: string;
     lastValidBlockHeight: number;
 }): Promise<RpcResponseAndContext<SignatureResult>>;

package/dist/cjs/node/utils/state-tree-lookup-table.d.ts

@@ -0,0 +1,68 @@
+import { PublicKey, Keypair, Connection } 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 newCpiContextAddresses    Addresses of the new cpi contexts to add
+ * @param payer                     Keypair of the payer
+ * @param authority                 Keypair of the authority
+ */
+export declare function extendStateTreeLookupTable({ connection, tableAddress, newStateTreeAddresses, newQueueAddresses, newCpiContextAddresses, payer, authority, }: {
+    connection: Connection;
+    tableAddress: PublicKey;
+    newStateTreeAddresses: PublicKey[];
+    newQueueAddresses: PublicKey[];
+    newCpiContextAddresses: PublicKey[];
+    payer: Keypair;
+    authority: Keypair;
+}): Promise<{
+    tableAddress: PublicKey;
+    txId: string;
+}>;
+/**
+ * Adds state tree address to lookup table. Acts as nullifier lookup for rolled
+ * over state trees.
+ *
+ * @internal
+ * @param connection                    Connection to the Solana network
+ * @param stateTreeAddress              Address of the state tree to nullify
+ * @param nullifyLookupTableAddress     Address of the 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, nullifyLookupTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
+    connection: Connection;
+    fullStateTreeAddress: PublicKey;
+    nullifyLookupTableAddress: PublicKey;
+    stateTreeLookupTableAddress: PublicKey;
+    payer: Keypair;
+    authority: Keypair;
+}): Promise<{
+    txId: string;
+}>;

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

@@ -1,7 +1,7 @@
 import BN from 'bn.js';
-import { CompressedAccount, CompressedAccountWithMerkleContext } from '../state';
+import { CompressedAccountLegacy, CompressedAccountWithMerkleContext } from '../state';
 export declare const validateSufficientBalance: (balance: BN) => void;
-export declare const validateSameOwner: (compressedAccounts: CompressedAccount[] | CompressedAccountWithMerkleContext[]) => void;
+export declare const validateSameOwner: (compressedAccounts: CompressedAccountLegacy[] | CompressedAccountWithMerkleContext[]) => void;
 export declare const validateNumbersForProof: (hashesLength: number, newAddressesLength: number) => void;
 export declare const validateNumbersForInclusionProof: (hashesLength: number) => void;
 export declare const validateNumbersForNonInclusionProof: (newAddressesLength: number) => void;