@lightprotocol/stateless.js 0.20.2 → 0.20.3

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

@@ -1,12 +1,39 @@
 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;
@@ -25,7 +52,12 @@ export declare function parseAccountData({ discriminator, data, dataHash, }: {
  *                                      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
@@ -33,9 +65,21 @@ export declare function createRpc(endpointOrWeb3JsConnection?: string | Connecti
  */
 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;
@@ -66,9 +110,18 @@ 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
  *
@@ -76,7 +129,10 @@ export declare function getPublicInputHash(accountProofs: MerkleContextWithMerkl
  * @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
  *
@@ -84,7 +140,10 @@ export declare function getQueueForTree(info: ActiveTreeBundle[], tree: PublicKe
  * @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.
  *
@@ -104,7 +163,12 @@ 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
      */
@@ -121,7 +185,10 @@ 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
      */
@@ -134,31 +201,46 @@ 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
      */
@@ -171,12 +253,18 @@ 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
@@ -184,19 +272,26 @@ 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
@@ -204,13 +299,19 @@ 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
      */
@@ -226,16 +327,25 @@ 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.
@@ -245,7 +355,9 @@ 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
@@ -265,7 +377,10 @@ 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.
      *
@@ -284,7 +399,10 @@ 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
@@ -299,7 +417,10 @@ 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
@@ -316,5 +437,8 @@ 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/node/state/BN254.d.ts

@@ -7,8 +7,15 @@ 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/node/state/compressed-account.d.ts

@@ -2,9 +2,10 @@ 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
  * */
@@ -26,6 +27,22 @@ 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/node/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/node/test-helpers/merkle-tree/indexed-array.d.ts

@@ -13,7 +13,11 @@ 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
@@ -23,7 +27,11 @@ 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;
@@ -63,7 +71,10 @@ 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.
@@ -75,7 +86,10 @@ 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/node/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,9 +23,16 @@ 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
@@ -63,7 +70,10 @@ 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[]}
@@ -88,5 +98,8 @@ 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/node/test-helpers/test-rpc/get-compressed-accounts.d.ts

@@ -2,6 +2,15 @@ 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/node/test-helpers/test-rpc/get-compressed-token-accounts.d.ts

@@ -22,7 +22,10 @@ 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.
  *
@@ -32,9 +35,22 @@ export declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAcc
  * @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/node/test-helpers/test-rpc/get-parsed-events.d.ts

@@ -8,8 +8,18 @@ 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 {};