@lightprotocol/stateless.js 0.20.3 → 0.20.4

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

@@ -1,39 +1,12 @@
 import { Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
 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 { 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,
-}: {
+export declare function parseAccountData({ discriminator, data, dataHash, }: {
     discriminator: BN;
     data: string;
     dataHash: BN;
@@ -52,12 +25,7 @@ export declare function parseAccountData({
  *                                      to endpoint
  * @param connectionConfig              Optional connection config
  */
-export declare function createRpc(
-    endpointOrWeb3JsConnection?: string | Connection,
-    compressionApiEndpoint?: string,
-    proverEndpoint?: string,
-    config?: ConnectionConfig,
-): Rpc;
+export declare function createRpc(endpointOrWeb3JsConnection?: string | Connection, compressionApiEndpoint?: string, proverEndpoint?: string, config?: ConnectionConfig): Rpc;
 /**
  * Helper function to preprocess the response to wrap numbers as strings
  * @param {string} text - The JSON string to preprocess
@@ -65,21 +33,9 @@ export declare function createRpc(
  */
 export declare function wrapBigNumbersAsStrings(text: string): string;
 /** @internal */
-export declare const rpcRequest: (
-    rpcEndpoint: string,
-    method: string,
-    params?: any,
-    convertToCamelCase?: boolean,
-    debug?: boolean,
-) => Promise<any>;
+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<CompressedProof>;
+export declare const proverRequest: (proverEndpoint: string, method: "inclusion" | "new-address" | "combined", params?: any, log?: boolean, publicInputHash?: BN | undefined) => Promise<CompressedProof>;
 export type NonInclusionMerkleProofInputs = {
     root: BN;
     value: BN;
@@ -110,18 +66,9 @@ export type NonInclusionJsonStruct = {
     leafHigherRangeValue: string;
     nextIndex: number;
 };
-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;
+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 queue for a given tree
  *
@@ -129,10 +76,7 @@ export declare function getPublicInputHash(
  * @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;
+export declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKey): PublicKey;
 /**
  * Get the tree for a given queue
  *
@@ -140,10 +84,7 @@ export declare function getQueueForTree(
  * @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;
+export declare function getTreeForQueue(info: ActiveTreeBundle[], queue: PublicKey): PublicKey;
 /**
  * Get a random tree and queue from the active state tree addresses.
  *
@@ -163,12 +104,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
     activeStateTreeInfo: ActiveTreeBundle[] | null;
-    constructor(
-        endpoint: string,
-        compressionApiEndpoint: string,
-        proverEndpoint: string,
-        config?: ConnectionConfig,
-    );
+    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
     /**
      * Manually set state tree addresses
      */
@@ -185,10 +121,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
     /**
      * Fetch the compressed account for the specified account address or hash
      */
-    getCompressedAccount(
-        address?: BN254,
-        hash?: BN254,
-    ): Promise<CompressedAccountWithMerkleContext | null>;
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
     /**
      * Fetch the compressed balance for the specified account address or hash
      */
@@ -201,46 +134,31 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * Fetch the latest merkle proof for the specified account hash from the
      * cluster
      */
-    getCompressedAccountProof(
-        hash: BN254,
-    ): Promise<MerkleContextWithMerkleProof>;
+    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[]>;
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
     /**
      * Fetch the latest merkle proofs for multiple compressed accounts specified
      * by an array account hashes
      */
-    getMultipleCompressedAccountProofs(
-        hashes: BN254[],
-    ): Promise<MerkleContextWithMerkleProof[]>;
+    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 | undefined,
-    ): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig | undefined): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
     /**
      * 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[]>>;
+    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[]>>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
     /**
      * Fetch the compressed token balance for the specified account hash
      */
@@ -253,18 +171,12 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * Fetch all the compressed token balances owned by the specified public
      * key. Can filter by mint. Returns without context.
      */
-    getCompressedTokenBalancesByOwner(
-        owner: PublicKey,
-        options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithCursor<TokenBalance[]>>;
+    getCompressedTokenBalancesByOwner(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<TokenBalance[]>>;
     /**
      * Fetch the compressed token balances owned by the specified public
      * key. Paginated. Can filter by mint. Returns with context.
      */
-    getCompressedTokenBalancesByOwnerV2(
-        owner: PublicKey,
-        options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    getCompressedTokenBalancesByOwnerV2(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
     /**
      * Returns confirmed compression signatures for transactions involving the specified
      * account hash forward in time from genesis to the most recent confirmed
@@ -272,26 +184,19 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      *
      * @param hash queried account hash
      */
-    getCompressionSignaturesForAccount(
-        hash: BN254,
-    ): Promise<SignatureWithMetadata[]>;
+    getCompressionSignaturesForAccount(hash: BN254): Promise<SignatureWithMetadata[]>;
     /**
      * Fetch a confirmed or finalized transaction from the cluster. Return with
      * CompressionInfo
      */
-    getTransactionWithCompressionInfo(
-        signature: string,
-    ): Promise<CompressedTransaction | null>;
+    getTransactionWithCompressionInfo(signature: string): Promise<CompressedTransaction | null>;
     /**
      * 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[]>>;
+    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
@@ -299,19 +204,13 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      *
      * @param owner queried owner public key
      */
-    getCompressionSignaturesForOwner(
-        owner: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithCursor<SignatureWithMetadata[]>>;
+    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[]>>;
+    getCompressionSignaturesForTokenOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
     /**
      * Fetch the current indexer health status
      */
@@ -327,25 +226,16 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
     /**
      * Fetch all the compressed token holders for a given mint. Paginated.
      */
-    getCompressedMintTokenHolders(
-        mint: PublicKey,
-        options?: PaginatedOptions,
-    ): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
+    getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
     /**
      * Fetch the latest compression signatures on the cluster. Results are
      * paginated.
      */
-    getLatestCompressionSignatures(
-        cursor?: string,
-        limit?: number,
-    ): Promise<LatestNonVotingSignaturesPaginated>;
+    getLatestCompressionSignatures(cursor?: string, limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
     /**
      * Fetch all non-voting signatures
      */
-    getLatestNonVotingSignatures(
-        limit?: number,
-        cursor?: string,
-    ): Promise<LatestNonVotingSignatures>;
+    getLatestNonVotingSignatures(limit?: number, cursor?: string): Promise<LatestNonVotingSignatures>;
     /**
      * Fetch the latest address proofs for new unique addresses specified by an
      * array of addresses.
@@ -355,9 +245,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param addresses Array of BN254 new addresses
      * @returns Array of validity proofs for new addresses
      */
-    getMultipleNewAddressProofs(
-        addresses: BN254[],
-    ): Promise<MerkleContextWithNewAddressProof[]>;
+    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
@@ -377,10 +265,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProofDirect(
-        hashes?: BN254[],
-        newAddresses?: BN254[],
-    ): Promise<CompressedProofWithContext>;
+    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
     /**
      * @deprecated use {@link getValidityProofV0} instead.
      *
@@ -399,10 +284,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProof(
-        hashes?: BN254[],
-        newAddresses?: BN254[],
-    ): Promise<CompressedProofWithContext>;
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -417,10 +299,7 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @param newAddresses  Array of { address: BN254, tree: PublicKey, queue: PublicKey }.
      * @returns             validity proof with context
      */
-    getValidityProofV0(
-        hashes?: HashWithTree[],
-        newAddresses?: AddressWithTree[],
-    ): Promise<CompressedProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -437,8 +316,5 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      *                      state tree/queue.
      * @returns             validity proof with context
      */
-    getValidityProofAndRpcContext(
-        hashes?: HashWithTree[],
-        newAddresses?: AddressWithTree[],
-    ): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
 }

package/dist/cjs/browser/state/BN254.d.ts

@@ -7,15 +7,8 @@ import { Buffer } from 'buffer';
  * are used to from working with the web3.js PublicKey type.
  */
 export type BN254 = BN;
-export declare const bn: (
-    number: string | number | BN | Buffer | Uint8Array | number[],
-    base?: number | 'hex' | undefined,
-    endian?: BN.Endianness | undefined,
-) => BN;
+export declare const bn: (number: string | number | BN | Buffer | Uint8Array | number[], base?: number | "hex" | undefined, endian?: BN.Endianness | undefined) => BN;
 /** Create a bigint instance with <254-bit max size and base58 capabilities */
-export declare const createBN254: (
-    number: string | number | BN | Buffer | Uint8Array | number[],
-    base?: number | 'hex' | 'base58' | undefined,
-) => BN254;
+export declare const createBN254: (number: string | number | BN | Buffer | Uint8Array | number[], base?: number | "hex" | "base58" | undefined) => BN254;
 /** Convert <254-bit bigint to Base58 string.  */
 export declare function encodeBN254toBase58(bigintNumber: BN): string;

package/dist/cjs/browser/state/compressed-account.d.ts

@@ -2,10 +2,9 @@ import BN from 'bn.js';
 import { PublicKey } from '@solana/web3.js';
 import { CompressedAccount, CompressedAccountData } from './types';
 import { BN254 } from './BN254';
-export type CompressedAccountWithMerkleContext = CompressedAccount &
-    MerkleContext & {
-        readOnly: boolean;
-    };
+export type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext & {
+    readOnly: boolean;
+};
 /**
  * Context for compressed account inserted into a state Merkle tree
  * */
@@ -27,22 +26,6 @@ export type MerkleContextWithMerkleProof = MerkleContext & {
     /** Current root */
     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: (
-    merkleTree: PublicKey,
-    nullifierQueue: PublicKey,
-    hash: number[],
-    leafIndex: number,
-) => MerkleContext;
+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: (merkleTree: PublicKey, nullifierQueue: PublicKey, hash: number[], leafIndex: number) => MerkleContext;

package/dist/cjs/browser/state/types.d.ts

@@ -18,7 +18,7 @@ export declare enum TreeType {
     /**
      * v2 address merkle tree
      */
-    BatchedAddress = 3,
+    BatchedAddress = 3
 }
 export type ActiveTreeBundle = {
     tree: PublicKey;

package/dist/cjs/browser/test-helpers/merkle-tree/indexed-array.d.ts

@@ -13,11 +13,7 @@ export declare class IndexedElementBundle {
     newLowElement: IndexedElement;
     newElement: IndexedElement;
     newElementNextValue: BN;
-    constructor(
-        newLowElement: IndexedElement,
-        newElement: IndexedElement,
-        newElementNextValue: BN,
-    );
+    constructor(newLowElement: IndexedElement, newElement: IndexedElement, newElementNextValue: BN);
 }
 /**
  * This indexed array implementation mirrors the rust implementation of the
@@ -27,11 +23,7 @@ export declare class IndexedArray {
     elements: Array<IndexedElement>;
     currentNodeIndex: number;
     highestElementIndex: number;
-    constructor(
-        elements: Array<IndexedElement>,
-        currentNodeIndex: number,
-        highestElementIndex: number,
-    );
+    constructor(elements: Array<IndexedElement>, currentNodeIndex: number, highestElementIndex: number);
     static default(): IndexedArray;
     get(index: number): IndexedElement | undefined;
     length(): number;
@@ -71,10 +63,7 @@ export declare class IndexedArray {
      * @param value The value of the new element to append.
      * @returns The new element and its updated low element.
      */
-    appendWithLowElementIndex(
-        lowElementIndex: number,
-        value: BN,
-    ): IndexedElementBundle;
+    appendWithLowElementIndex(lowElementIndex: number, value: BN): IndexedElementBundle;
     /**
      * Finds the lowest element in the array.
      * @returns The lowest element or undefined if the array is empty.
@@ -86,10 +75,7 @@ export declare class IndexedArray {
      * @param value The value for the new element.
      * @returns A bundle containing the new element, the updated low element, and the value of the next element.
      */
-    newElementWithLowElementIndex(
-        lowElementIndex: number,
-        value: BN,
-    ): IndexedElementBundle;
+    newElementWithLowElementIndex(lowElementIndex: number, value: BN): IndexedElementBundle;
     /**
      * Creates a new element with the specified value by first finding the appropriate low element index.
      * @param value The value for the new element.

package/dist/cjs/browser/test-helpers/merkle-tree/merkle-tree.d.ts

@@ -1,5 +1,5 @@
 import { LightWasm } from '../test-rpc/test-rpc';
-export declare const DEFAULT_ZERO = '0';
+export declare const DEFAULT_ZERO = "0";
 /**
  * @callback hashFunction
  * @param left Left leaf
@@ -23,16 +23,9 @@ export declare class MerkleTree {
     _zeros: string[];
     _layers: string[][];
     _lightWasm: LightWasm;
-    constructor(
-        levels: number,
-        lightWasm: LightWasm,
-        elements?: string[],
-        {
-            zeroElement,
-        }?: {
-            zeroElement?: string | undefined;
-        },
-    );
+    constructor(levels: number, lightWasm: LightWasm, elements?: string[], { zeroElement }?: {
+        zeroElement?: string | undefined;
+    });
     _rebuild(): void;
     /**
      * Get tree root
@@ -70,10 +63,7 @@ export declare class MerkleTree {
      * @param comparator A function that checks leaf value equality
      * @returns {number} Index if element is found, otherwise -1
      */
-    indexOf(
-        element: string,
-        comparator?: ((element: string, el: string) => boolean) | null,
-    ): number;
+    indexOf(element: string, comparator?: ((element: string, el: string) => boolean) | null): number;
     /**
      * Returns a copy of non-zero tree elements
      * @returns {Object[]}
@@ -98,8 +88,5 @@ export declare class MerkleTree {
      * @param hashFunction
      * @returns {MerkleTree}
      */
-    static deserialize(
-        data: any,
-        hashFunction: (left: string, right: string) => string,
-    ): any;
+    static deserialize(data: any, hashFunction: (left: string, right: string) => string): any;
 }

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

@@ -2,15 +2,6 @@ import { PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { Rpc } from '../../rpc';
 import { CompressedAccountWithMerkleContext } from '../../state';
-export declare function getCompressedAccountsByOwnerTest(
-    rpc: Rpc,
-    owner: PublicKey,
-): Promise<CompressedAccountWithMerkleContext[]>;
-export declare function getCompressedAccountByHashTest(
-    rpc: Rpc,
-    hash: BN,
-): Promise<CompressedAccountWithMerkleContext | undefined>;
-export declare function getMultipleCompressedAccountsByHashTest(
-    rpc: Rpc,
-    hashes: BN[],
-): Promise<CompressedAccountWithMerkleContext[]>;
+export declare function getCompressedAccountsByOwnerTest(rpc: Rpc, owner: PublicKey): Promise<CompressedAccountWithMerkleContext[]>;
+export declare function getCompressedAccountByHashTest(rpc: Rpc, hash: BN): Promise<CompressedAccountWithMerkleContext | undefined>;
+export declare function getMultipleCompressedAccountsByHashTest(rpc: Rpc, hashes: BN[]): Promise<CompressedAccountWithMerkleContext[]>;

package/dist/cjs/browser/test-helpers/test-rpc/get-compressed-token-accounts.d.ts

@@ -22,10 +22,7 @@ export type EventWithParsedTokenTlvData = {
  * @param compressedAccount - The compressed account
  * @returns The parsed token data
  */
-export declare function parseTokenLayoutWithIdl(
-    compressedAccount: CompressedAccount,
-    programId?: PublicKey,
-): TokenData | null;
+export declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccount, programId?: PublicKey): TokenData | null;
 /**
  * Retrieves all compressed token accounts for a given mint and owner.
  *
@@ -35,22 +32,9 @@ export declare function parseTokenLayoutWithIdl(
  * @param owner     PublicKey of the token owner
  * @param mint      PublicKey of the token mint
  */
-export declare function getCompressedTokenAccounts(
-    events: PublicTransactionEvent[],
-): Promise<ParsedTokenAccount[]>;
+export declare function getCompressedTokenAccounts(events: PublicTransactionEvent[]): Promise<ParsedTokenAccount[]>;
 /** @internal */
-export declare function getCompressedTokenAccountsByOwnerTest(
-    rpc: Rpc,
-    owner: PublicKey,
-    mint: PublicKey,
-): Promise<WithCursor<ParsedTokenAccount[]>>;
-export declare function getCompressedTokenAccountsByDelegateTest(
-    rpc: Rpc,
-    delegate: PublicKey,
-    mint: PublicKey,
-): Promise<WithCursor<ParsedTokenAccount[]>>;
-export declare function getCompressedTokenAccountByHashTest(
-    rpc: Rpc,
-    hash: BN,
-): Promise<ParsedTokenAccount>;
+export declare function getCompressedTokenAccountsByOwnerTest(rpc: Rpc, owner: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
+export declare function getCompressedTokenAccountsByDelegateTest(rpc: Rpc, delegate: PublicKey, mint: PublicKey): Promise<WithCursor<ParsedTokenAccount[]>>;
+export declare function getCompressedTokenAccountByHashTest(rpc: Rpc, hash: BN): Promise<ParsedTokenAccount>;
 export {};

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

@@ -8,18 +8,8 @@ type Deserializer<T> = (data: Buffer, tx: ParsedTransactionWithMeta) => T;
  * Returns newest first.
  *
  * */
-export declare function getParsedEvents(
-    rpc: Rpc,
-): Promise<PublicTransactionEvent[]>;
-export declare const parseEvents: <T>(
-    indexerEventsTransactions: (ParsedTransactionWithMeta | null)[],
-    deserializeFn: Deserializer<T>,
-) => NonNullable<T>[];
-export declare const parsePublicTransactionEventWithIdl: (
-    data: Buffer,
-) => PublicTransactionEvent | null;
-export declare function parseLightTransaction(
-    dataVec: Uint8Array[],
-    accountKeys: PublicKey[][],
-): PublicTransactionEvent | null | undefined;
+export declare function getParsedEvents(rpc: Rpc): Promise<PublicTransactionEvent[]>;
+export declare const parseEvents: <T>(indexerEventsTransactions: (ParsedTransactionWithMeta | null)[], deserializeFn: Deserializer<T>) => NonNullable<T>[];
+export declare const parsePublicTransactionEventWithIdl: (data: Buffer) => PublicTransactionEvent | null;
+export declare function parseLightTransaction(dataVec: Uint8Array[], accountKeys: PublicKey[][]): PublicTransactionEvent | null | undefined;
 export {};