@lightprotocol/stateless.js 0.22.0 → 0.22.1-alpha.1

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

@@ -0,0 +1,239 @@
+import { 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 { MerkleContextWithNewAddressProof } from '../../rpc';
+import { TreeInfo } from '../../state/types';
+export interface TestRpcConfig {
+    /**
+     * Depth of state tree. Defaults to the public default test state tree depth
+     */
+    depth?: number;
+    /**
+     * Log proof generation time
+     */
+    log?: boolean;
+}
+export type ClientSubscriptionId = number;
+export interface LightWasm {
+    blakeHash(input: string | Uint8Array, hashLength: number): Uint8Array;
+    poseidonHash(input: string[] | BN[]): Uint8Array;
+    poseidonHashString(input: string[] | BN[]): string;
+    poseidonHashBN(input: string[] | BN[]): BN;
+}
+/**
+ * Returns a mock RPC instance for use in unit tests.
+ *
+ * @param lightWasm               Wasm hasher instance.
+ * @param endpoint                RPC endpoint URL. Defaults to
+ *                                'http://127.0.0.1:8899'.
+ * @param proverEndpoint          Prover server endpoint URL. Defaults to
+ *                                'http://localhost:3001'.
+ * @param merkleTreeAddress       Address of the merkle tree to index. Defaults
+ *                                to the public default test state tree.
+ * @param nullifierQueueAddress   Optional address of the associated nullifier
+ *                                queue.
+ * @param depth                   Depth of the merkle tree.
+ * @param log                     Log proof generation time.
+ */
+export declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, depth?: number, log?: boolean): Promise<TestRpc>;
+/**
+ * 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 up to 1000 transactions
+ *
+ * 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;
+    proverEndpoint: string;
+    lightWasm: LightWasm;
+    depth: number;
+    log: boolean;
+    allStateTreeInfos: TreeInfo[] | null;
+    lastStateTreeFetchTime: number | null;
+    fetchPromise: Promise<TreeInfo[]> | null;
+    CACHE_TTL: number;
+    /**
+     * Establish a Compression-compatible JSON RPC mock-connection
+     *
+     * @param endpoint                  endpoint to the solana cluster (use for
+     *                                  localnet only)
+     * @param hasher                    light wasm hasher instance
+     * @param compressionApiEndpoint    Endpoint to the compression server.
+     * @param proverEndpoint            Endpoint to the prover server. defaults
+     *                                  to endpoint
+     * @param connectionConfig          Optional connection config
+     * @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
+     */
+    getCachedActiveStateTreeInfos(): Promise<void>;
+    /**
+     * Returns local test state trees.
+     */
+    getStateTreeInfos(): Promise<TreeInfo[]>;
+    doFetch(): Promise<TreeInfo[]>;
+    /**
+     * Get a V2 address tree info.
+     */
+    getAddressTreeInfoV2(): Promise<TreeInfo>;
+    /**
+     * Fetch the compressed account for the specified account hash
+     */
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
+    /**
+     * Fetch the compressed balance for the specified account hash
+     */
+    getCompressedBalance(address?: BN254, hash?: BN254): Promise<BN>;
+    /**
+     * Fetch the total compressed balance for the specified owner public key
+     */
+    getCompressedBalanceByOwner(owner: PublicKey): Promise<BN>;
+    /**
+     * Fetch the latest merkle proof for the specified account hash from the
+     * cluster
+     */
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
+    /**
+     * Fetch all the account info for multiple compressed accounts specified by
+     * an array of account hashes
+     */
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
+    /**
+     * Ensure that the Compression Indexer has already indexed the transaction
+     */
+    confirmTransactionIndexed(_slot: number): Promise<boolean>;
+    /**
+     * Fetch the latest merkle proofs for multiple compressed accounts specified
+     * by an array account hashes
+     */
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
+    /**
+     * Fetch all the compressed accounts owned by the specified public key.
+     * Owner can be a program or user account
+     */
+    getCompressedAccountsByOwner(owner: PublicKey, _config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    /**
+     * Fetch the latest compression signatures on the cluster. Results are
+     * paginated.
+     */
+    getLatestCompressionSignatures(_cursor?: string, _limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
+    /**
+     * Fetch the latest non-voting signatures on the cluster. Results are
+     * not paginated.
+     */
+    getLatestNonVotingSignatures(_limit?: number): Promise<LatestNonVotingSignatures>;
+    /**
+     * Fetch all the compressed token accounts owned by the specified public
+     * key. Owner can be a program or user account
+     */
+    getCompressedTokenAccountsByOwner(owner: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
+    /**
+     * Fetch all the compressed accounts delegated to the specified public key.
+     */
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
+    /**
+     * Fetch the compressed token balance for the specified account hash
+     */
+    getCompressedTokenAccountBalance(hash: BN254): Promise<{
+        amount: BN;
+    }>;
+    /**
+     * @deprecated use {@link getCompressedTokenBalancesByOwnerV2}.
+     * Fetch all the compressed token balances owned by the specified public
+     * key. Can filter by mint.
+     */
+    getCompressedTokenBalancesByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<{
+        balance: BN;
+        mint: PublicKey;
+    }[]>>;
+    /**
+     * Fetch all the compressed token balances owned by the specified public
+     * key. Can filter by mint. Uses context.
+     */
+    getCompressedTokenBalancesByOwnerV2(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    /**
+     * Returns confirmed signatures for transactions involving the specified
+     * account hash forward in time from genesis to the most recent confirmed
+     * block
+     *
+     * @param hash queried account hash
+     */
+    getCompressionSignaturesForAccount(_hash: BN254): Promise<SignatureWithMetadata[]>;
+    /**
+     * Fetch a confirmed or finalized transaction from the cluster. Return with
+     * CompressionInfo
+     */
+    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction>;
+    /**
+     * Returns confirmed signatures for transactions involving the specified
+     * address forward in time from genesis to the most recent confirmed
+     * block
+     *
+     * @param address queried compressed account address
+     */
+    getCompressionSignaturesForAddress(_address: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    /**
+     * Returns confirmed signatures for compression transactions involving the
+     * specified account owner forward in time from genesis to the
+     * most recent confirmed block
+     *
+     * @param owner queried owner public key
+     */
+    getCompressionSignaturesForOwner(_owner: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    /**
+     * Returns confirmed signatures for compression transactions involving the
+     * specified token account owner forward in time from genesis to the most
+     * recent confirmed block
+     */
+    getCompressionSignaturesForTokenOwner(_owner: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    /**
+     * Fetch the current indexer health status
+     */
+    getIndexerHealth(): Promise<string>;
+    /**
+     * Fetch the current slot that the node is processing
+     */
+    getIndexerSlot(): Promise<number>;
+    /**
+     * Fetch the latest address proofs for new unique addresses specified by an
+     * array of addresses.
+     *
+     * the proof states that said address have not yet been created in respective address tree.
+     * @param addresses Array of BN254 new addresses
+     * @returns Array of validity proofs for new addresses
+     */
+    getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
+    getCompressedMintTokenHolders(_mint: PublicKey, _options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
+    /**
+     * @deprecated This method is not available for TestRpc. Please use
+     * {@link getValidityProof} instead.
+     */
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
+    /**
+     * 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
+     */
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
+}

package/dist/es/browser/test-helpers/test-utils.d.ts

@@ -0,0 +1,31 @@
+import { Connection, Keypair, Signer } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+export declare const ALICE: Keypair;
+export declare const BOB: Keypair;
+export declare const CHARLIE: Keypair;
+export declare const DAVE: Keypair;
+/**
+ * Deep comparison of two objects. Handles BN comparison correctly.
+ *
+ * @param ref - The reference object to compare.
+ * @param val - The value object to compare.
+ * @returns True if the objects are deeply equal, false otherwise.
+ */
+export declare function deepEqual(ref: any, val: any): boolean;
+/**
+ * Create a new account and airdrop lamports to it
+ *
+ * @param rpc       connection to use
+ * @param lamports  amount of lamports to airdrop
+ * @param counter   counter to use for generating the keypair.
+ *                  If undefined or >255, generates random keypair.
+ */
+export declare function newAccountWithLamports(rpc: Rpc, lamports?: number, counter?: number | undefined): Promise<Signer>;
+export declare function getConnection(): Connection;
+/**
+ * For use in tests.
+ * Generate a unique keypair by passing in a counter <255. If no counter
+ * is supplied, it uses and increments a global counter.
+ * if counter > 255, generates random keypair
+ */
+export declare function getTestKeypair(counter?: number | undefined): Keypair;

package/dist/es/browser/utils/address.d.ts

@@ -0,0 +1,64 @@
+import { PublicKey } from '@solana/web3.js';
+export declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
+export declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
+export declare function deriveAddressSeedV2(seeds: Uint8Array[]): Uint8Array;
+/**
+ * Derives an address from a seed using the v2 method (matching Rust's derive_address_from_seed)
+ *
+ * @param addressSeed              The address seed (32 bytes)
+ * @param addressMerkleTreePubkey  Merkle tree public key
+ * @param programId                Program ID
+ * @returns                        Derived address
+ */
+export declare function deriveAddressV2(addressSeed: Uint8Array, addressMerkleTreePubkey: PublicKey, programId: PublicKey): PublicKey;
+export interface NewAddressParams {
+    /**
+     * Seed for the compressed account. Must be seed used to derive
+     * newAccountAddress
+     */
+    seed: Uint8Array;
+    /**
+     * Recent state root index of the address tree. The expiry is tied to the
+     * validity proof.
+     */
+    addressMerkleTreeRootIndex: number;
+    /**
+     * Address tree pubkey. Must be base pubkey used to derive new address
+     */
+    addressMerkleTreePubkey: PublicKey;
+    /**
+     * Address space queue pubkey. Associated with the state tree.
+     */
+    addressQueuePubkey: PublicKey;
+}
+export interface NewAddressParamsPacked {
+    /**
+     * Seed for the compressed account. Must be seed used to derive
+     * newAccountAddress
+     */
+    seed: number[];
+    /**
+     * Recent state root index of the address tree. The expiry is tied to the
+     * validity proof.
+     */
+    addressMerkleTreeRootIndex: number;
+    /**
+     * Index of the address merkle tree account in the remaining accounts array
+     */
+    addressMerkleTreeAccountIndex: number;
+    /**
+     * Index of the address queue account in the remaining accounts array
+     */
+    addressQueueAccountIndex: number;
+}
+/**
+ * Packs new address params for instruction data in TypeScript clients
+ *
+ * @param newAddressParams      New address params
+ * @param remainingAccounts     Remaining accounts
+ * @returns                     Packed new address params
+ */
+export declare function packNewAddressParams(newAddressParams: NewAddressParams[], remainingAccounts: PublicKey[]): {
+    newAddressParamsPacked: NewAddressParamsPacked[];
+    remainingAccounts: PublicKey[];
+};

package/dist/es/browser/utils/airdrop.d.ts

@@ -0,0 +1,7 @@
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+export declare function airdropSol({ connection, lamports, recipientPublicKey, }: {
+    connection: Connection;
+    lamports: number;
+    recipientPublicKey: PublicKey;
+}): Promise<string>;
+export declare function confirmTransaction(connection: Connection, signature: string, confirmation?: Commitment): Promise<import("@solana/web3.js").RpcResponseAndContext<import("@solana/web3.js").SignatureResult>>;

package/dist/es/browser/utils/calculate-compute-unit-price.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @param targetLamports - Target priority fee in lamports
+ * @param computeUnits - Expected compute units used by the transaction
+ * @returns microLamports per compute unit (use in
+ * {@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/es/browser/utils/conversion.d.ts

@@ -0,0 +1,36 @@
+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
+ * convert BN to hex with '0x' prefix
+ */
+export declare function toHex(bn: BN): string;
+export declare const toArray: <T>(value: T | T[]) => T[];
+export declare const bufToDecStr: (buf: Buffer) => string;
+export declare function isSmallerThanBn254FieldSizeBe(bytes: Buffer): boolean;
+export declare const toCamelCase: (object: any) => any;
+/**
+/**
+ * Hash the provided `bytes` with Keccak256 and ensure the result fits in the
+ * BN254 prime field by repeatedly hashing the inputs with various "bump seeds"
+ * and truncating the resulting hash to 31 bytes.
+ *
+ * @deprecated Use `hashvToBn254FieldSizeBe` instead.
+ */
+export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number] | null;
+export declare function hashvToBn254FieldSizeBeU8Array(bytes: Uint8Array[]): Uint8Array;
+/**
+ * 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.
+ *
+ * @param bytes Input bytes
+ *
+ * @returns     Hash digest
+ */
+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;

package/dist/es/browser/utils/dedupe-signer.d.ts

@@ -0,0 +1,3 @@
+import { Signer } from '@solana/web3.js';
+/** @internal remove signer from signers if part of signers */
+export declare function dedupeSigner(signer: Signer, signers: Signer[]): Signer[];

package/dist/es/browser/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/es/browser/utils/index.d.ts

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

package/dist/es/browser/utils/instruction.d.ts

@@ -0,0 +1,35 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+export declare class PackedAccounts {
+    private preAccounts;
+    private systemAccounts;
+    private nextIndex;
+    private map;
+    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccounts;
+    static newWithSystemAccountsV2(config: SystemAccountMetaConfig): PackedAccounts;
+    addPreAccountsSigner(pubkey: PublicKey): void;
+    addPreAccountsSignerMut(pubkey: PublicKey): void;
+    addPreAccountsMeta(accountMeta: AccountMeta): void;
+    addSystemAccounts(config: SystemAccountMetaConfig): void;
+    addSystemAccountsV2(config: SystemAccountMetaConfig): void;
+    insertOrGet(pubkey: PublicKey): number;
+    insertOrGetReadOnly(pubkey: PublicKey): number;
+    insertOrGetConfig(pubkey: PublicKey, isSigner: boolean, isWritable: boolean): number;
+    private hashSetAccountsToMetas;
+    private getOffsets;
+    toAccountMetas(): {
+        remainingAccounts: AccountMeta[];
+        systemStart: number;
+        packedStart: number;
+    };
+}
+export declare class SystemAccountMetaConfig {
+    selfProgram: PublicKey;
+    cpiContext?: PublicKey;
+    solCompressionRecipient?: PublicKey;
+    solPoolPda?: PublicKey;
+    private constructor();
+    static new(selfProgram: PublicKey): SystemAccountMetaConfig;
+    static newWithCpiContext(selfProgram: PublicKey, cpiContext: PublicKey): SystemAccountMetaConfig;
+}
+export declare function getLightSystemAccountMetas(config: SystemAccountMetaConfig): AccountMeta[];
+export declare function getLightSystemAccountMetasV2(config: SystemAccountMetaConfig): AccountMeta[];

package/dist/es/browser/utils/parse-validity-proof.d.ts

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

package/dist/es/browser/utils/pipe.d.ts

@@ -0,0 +1,2 @@
+/** pipe function */
+export declare function pipe<T, R>(initialFunction: (arg: T) => R, ...functions: ((arg: R) => R)[]): (initialValue: T) => R;

package/dist/es/browser/utils/send-and-confirm.d.ts

@@ -0,0 +1,52 @@
+import { VersionedTransaction, SignatureResult, RpcResponseAndContext, Signer, TransactionInstruction, ConfirmOptions, TransactionSignature, PublicKey, AddressLookupTableAccount } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+/**
+ * Builds a versioned Transaction from instructions.
+ *
+ * @param instructions          instructions to include
+ * @param payerPublicKey        fee payer public key
+ * @param blockhash             blockhash to use
+ * @param lookupTableAccounts   lookup table accounts to include
+ *
+ * @return VersionedTransaction
+ */
+export declare function buildTx(instructions: TransactionInstruction[], payerPublicKey: PublicKey, blockhash: string, lookupTableAccounts?: AddressLookupTableAccount[]): VersionedTransaction;
+/**
+ * Sends a versioned transaction and confirms it.
+ *
+ * @param rpc               connection to use
+ * @param tx                versioned transaction to send
+ * @param confirmOptions    confirmation options
+ * @param blockHashCtx      blockhash context for confirmation
+ *
+ * @return TransactionSignature
+ */
+export declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+    blockhash: string;
+    lastValidBlockHeight: number;
+}): Promise<TransactionSignature>;
+/**
+ * Confirms a transaction with a given txId.
+ *
+ * @param rpc               connection to use
+ * @param txId              transaction signature to confirm
+ * @param confirmOptions    confirmation options
+ * @param blockHashCtx      blockhash context for confirmation
+ * @return SignatureResult
+ */
+export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, _blockHashCtx?: {
+    blockhash: string;
+    lastValidBlockHeight: number;
+}): Promise<RpcResponseAndContext<SignatureResult>>;
+/**
+ * Builds a versioned Transaction from instructions and signs it.
+ *
+ * @param instructions          instructions to include in the transaction
+ * @param payer                 payer of the transaction
+ * @param blockhash             recent blockhash to use in the transaction
+ * @param additionalSigners     non-feepayer signers to include in the
+ *                              transaction
+ * @param lookupTableAccounts   lookup table accounts to include in the
+ *                              transaction
+ */
+export declare function buildAndSignTx(instructions: TransactionInstruction[], payer: Signer, blockhash: string, additionalSigners?: Signer[], lookupTableAccounts?: AddressLookupTableAccount[]): VersionedTransaction;

package/dist/es/browser/utils/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<void>;

package/dist/es/browser/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/es/browser/utils/validation.d.ts

@@ -0,0 +1,8 @@
+import BN from 'bn.js';
+import { CompressedAccountLegacy, CompressedAccountWithMerkleContext } from '../state';
+export declare const validateSufficientBalance: (balance: BN) => 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;
+export declare const validateNumbers: (length: number, allowedNumbers: number[], type: string) => void;