@lightprotocol/stateless.js 0.20.3 → 0.20.5

package/dist/cjs/node/test-helpers/test-rpc/test-rpc.d.ts

@@ -1,30 +1,8 @@
 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 {
-    CompressedProofWithContext,
-    CompressionApiInterface,
-    GetCompressedTokenAccountsByOwnerOrDelegateOptions,
-    ParsedTokenAccount,
-    TokenBalance,
-} from '../../rpc-interface';
-import {
-    BN254,
-    CompressedAccountWithMerkleContext,
-    MerkleContextWithMerkleProof,
-} from '../../state';
+import { AddressWithTree, CompressedMintTokenHolders, CompressedTransaction, GetCompressedAccountsByOwnerConfig, PaginatedOptions, HashWithTree, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, SignatureWithMetadata, WithContext, WithCursor } from '../../rpc-interface';
+import { CompressedProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
+import { BN254, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof } from '../../state';
 import { MerkleContextWithNewAddressProof } from '../../rpc';
 import { ActiveTreeBundle } from '../../state/types';
 export interface TestRpcConfig {
@@ -77,16 +55,7 @@ export interface LightWasm {
  * @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,
-    merkleTreeAddress?: PublicKey,
-    nullifierQueueAddress?: PublicKey,
-    depth?: number,
-    log?: boolean,
-): Promise<TestRpc>;
+export declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, merkleTreeAddress?: PublicKey, nullifierQueueAddress?: PublicKey, depth?: number, log?: boolean): Promise<TestRpc>;
 /**
  * Simple mock rpc for unit tests that simulates the compression rpc interface.
  * Fetches, parses events and builds merkletree on-demand, i.e. it does not persist state.
@@ -96,10 +65,7 @@ export declare function getTestRpc(
  *
  * For advanced testing use photon: https://github.com/helius-labs/photon
  */
-export declare class TestRpc
-    extends Connection
-    implements CompressionApiInterface
-{
+export declare class TestRpc extends Connection implements CompressionApiInterface {
     compressionApiEndpoint: string;
     proverEndpoint: string;
     merkleTreeAddress: PublicKey;
@@ -122,14 +88,7 @@ export declare class TestRpc
      * @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,
-    );
+    constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
     /**
      * Manually set state tree addresses
      */
@@ -145,10 +104,7 @@ export declare class TestRpc
     /**
      * Fetch the compressed account for the specified account 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 hash
      */
@@ -161,16 +117,12 @@ export declare class TestRpc
      * 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[]>;
     /**
      * Ensure that the Compression Indexer has already indexed the transaction
      */
@@ -179,47 +131,31 @@ export declare class TestRpc
      * 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,
-    ): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    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>;
+    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>;
+    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[]>>;
+    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
      */
@@ -231,25 +167,15 @@ export declare class TestRpc
      * 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;
-            }[]
-        >
-    >;
+    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[]>>>;
+    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
@@ -257,16 +183,12 @@ export declare class TestRpc
      *
      * @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
@@ -274,10 +196,7 @@ export declare class TestRpc
      *
      * @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
@@ -285,19 +204,13 @@ export declare class TestRpc
      *
      * @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
      */
@@ -314,13 +227,8 @@ export declare class TestRpc
      * @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[]>>>;
+    getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
+    getCompressedMintTokenHolders(_mint: PublicKey, _options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
     /**
      * Advanced usage of getValidityProof: fetches ZKP directly from a custom
      * non-rpcprover. Note: This uses the proverEndpoint specified in the
@@ -330,18 +238,12 @@ export declare class TestRpc
      * Note: Use RPC class for forested trees. TestRpc is only for custom
      * testing purposes.
      */
-    getValidityProofDirect(
-        hashes?: BN254[],
-        newAddresses?: BN254[],
-    ): Promise<CompressedProofWithContext>;
+    getValidityProofDirect(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
     /**
      * @deprecated This method is not available for TestRpc. Please use
      * {@link getValidityProof} instead.
      */
-    getValidityProofAndRpcContext(
-        hashes?: HashWithTree[],
-        newAddresses?: AddressWithTree[],
-    ): Promise<WithContext<CompressedProofWithContext>>;
+    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -356,12 +258,6 @@ export declare class TestRpc
      * @param newAddresses  Array of BN254 new addresses.
      * @returns             validity proof with context
      */
-    getValidityProof(
-        hashes?: BN254[],
-        newAddresses?: BN254[],
-    ): Promise<CompressedProofWithContext>;
-    getValidityProofV0(
-        hashes?: HashWithTree[],
-        newAddresses?: AddressWithTree[],
-    ): Promise<CompressedProofWithContext>;
+    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
+    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
 }

package/dist/cjs/node/test-helpers/test-utils.d.ts

@@ -20,11 +20,7 @@ export declare function deepEqual(ref: any, val: any): boolean;
  * @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 newAccountWithLamports(rpc: Rpc, lamports?: number, counter?: number | undefined): Promise<Signer>;
 export declare function getConnection(): Connection;
 /**
  * For use in tests.

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

@@ -1,8 +1,5 @@
 import { PublicKey } from '@solana/web3.js';
-export declare function deriveAddressSeed(
-    seeds: Uint8Array[],
-    programId: PublicKey,
-): Uint8Array;
+export declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
 /**
  * Derive an address for a compressed account from a seed and an address Merkle
  * tree public key.
@@ -12,10 +9,7 @@ export declare function deriveAddressSeed(
  *                                 defaultTestStateTreeAccounts().addressTree
  * @returns                        Derived address
  */
-export declare function deriveAddress(
-    seed: Uint8Array,
-    addressMerkleTreePubkey?: PublicKey,
-): PublicKey;
+export declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
 export interface NewAddressParams {
     /**
      * Seed for the compressed account. Must be seed used to derive
@@ -63,10 +57,7 @@ export interface NewAddressParamsPacked {
  * @param remainingAccounts     Remaining accounts
  * @returns                     Packed new address params
  */
-export declare function packNewAddressParams(
-    newAddressParams: NewAddressParams[],
-    remainingAccounts: PublicKey[],
-): {
+export declare function packNewAddressParams(newAddressParams: NewAddressParams[], remainingAccounts: PublicKey[]): {
     newAddressParamsPacked: NewAddressParamsPacked[];
     remainingAccounts: PublicKey[];
 };

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

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

package/dist/cjs/node/utils/calculate-compute-unit-price.d.ts

@@ -4,7 +4,4 @@
  * @returns microLamports per compute unit (use in
  * `ComputeBudgetProgram.setComputeUnitPrice`)
  */
-export declare function calculateComputeUnitPrice(
-    targetLamports: number,
-    computeUnits: number,
-): number;
+export declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;

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

@@ -9,6 +9,9 @@ export declare function byteArrayToKeypair(byteArray: number[]): Keypair;
 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"
@@ -16,9 +19,7 @@ export declare const bufToDecStr: (buf: Buffer) => string;
  *
  * @deprecated Use `hashvToBn254FieldSizeBe` instead.
  */
-export declare function hashToBn254FieldSizeBe(
-    bytes: Buffer,
-): [Buffer, number] | null;
+export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number] | null;
 /**
  * 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.
@@ -27,11 +28,6 @@ export declare function hashToBn254FieldSizeBe(
  *
  * @returns     Hash digest
  */
-export declare function hashvToBn254FieldSizeBe(
-    bytes: Uint8Array[],
-): Uint8Array;
+export declare function hashvToBn254FieldSizeBe(bytes: Uint8Array[]): Uint8Array;
 /** Mutates array in place */
 export declare function pushUniqueItems<T>(items: T[], map: T[]): void;
-export declare function toCamelCase(
-    obj: Array<any> | unknown | any,
-): Array<any> | unknown | any;

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

@@ -10,12 +10,7 @@ import { ActiveTreeBundle } from '../state/types';
  * @param authority - Keypair of the authority
  * @param recentSlot - Slot of the recent block
  */
-export declare function createStateTreeLookupTable({
-    connection,
-    payer,
-    authority,
-    recentSlot,
-}: {
+export declare function createStateTreeLookupTable({ connection, payer, authority, recentSlot, }: {
     connection: Connection;
     payer: Keypair;
     authority: Keypair;
@@ -35,15 +30,7 @@ export declare function createStateTreeLookupTable({
  * @param payer - Keypair of the payer
  * @param authority - Keypair of the authority
  */
-export declare function extendStateTreeLookupTable({
-    connection,
-    tableAddress,
-    newStateTreeAddresses,
-    newQueueAddresses,
-    newCpiContextAddresses,
-    payer,
-    authority,
-}: {
+export declare function extendStateTreeLookupTable({ connection, tableAddress, newStateTreeAddresses, newQueueAddresses, newCpiContextAddresses, payer, authority, }: {
     connection: Connection;
     tableAddress: PublicKey;
     newStateTreeAddresses: PublicKey[];
@@ -68,14 +55,7 @@ export declare function extendStateTreeLookupTable({
  * @param payer - Keypair of the payer
  * @param authority - Keypair of the authority
  */
-export declare function nullifyLookupTable({
-    connection,
-    fullStateTreeAddress,
-    nullifyTableAddress,
-    stateTreeLookupTableAddress,
-    payer,
-    authority,
-}: {
+export declare function nullifyLookupTable({ connection, fullStateTreeAddress, nullifyTableAddress, stateTreeLookupTableAddress, payer, authority, }: {
     connection: Connection;
     fullStateTreeAddress: PublicKey;
     nullifyTableAddress: PublicKey;
@@ -89,11 +69,7 @@ export declare function nullifyLookupTable({
  *  Get most recent , active state tree data
  * we store in lookup table for each public state tree
  */
-export declare function getLightStateTreeInfo({
-    connection,
-    stateTreeLookupTableAddress,
-    nullifyTableAddress,
-}: {
+export declare function getLightStateTreeInfo({ connection, stateTreeLookupTableAddress, nullifyTableAddress, }: {
     connection: Connection;
     stateTreeLookupTableAddress: PublicKey;
     nullifyTableAddress: PublicKey;

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

@@ -16,7 +16,5 @@ export declare const placeholderValidityProof: () => {
 };
 export declare const checkValidityProofShape: (proof: CompressedProof) => void;
 export declare function proofFromJsonStruct(json: GnarkProofJson): ProofABC;
-export declare function negateAndCompressProof(
-    proof: ProofABC,
-): CompressedProof;
+export declare function negateAndCompressProof(proof: ProofABC): CompressedProof;
 export {};

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

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

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

@@ -1,14 +1,4 @@
-import {
-    VersionedTransaction,
-    SignatureResult,
-    RpcResponseAndContext,
-    Signer,
-    TransactionInstruction,
-    ConfirmOptions,
-    TransactionSignature,
-    PublicKey,
-    AddressLookupTableAccount,
-} from '@solana/web3.js';
+import { VersionedTransaction, SignatureResult, RpcResponseAndContext, Signer, TransactionInstruction, ConfirmOptions, TransactionSignature, PublicKey, AddressLookupTableAccount } from '@solana/web3.js';
 import { Rpc } from '../rpc';
 /**
  * Builds a versioned Transaction from instructions.
@@ -20,12 +10,7 @@ import { Rpc } from '../rpc';
  *
  * @return VersionedTransaction
  */
-export declare function buildTx(
-    instructions: TransactionInstruction[],
-    payerPublicKey: PublicKey,
-    blockhash: string,
-    lookupTableAccounts?: AddressLookupTableAccount[],
-): VersionedTransaction;
+export declare function buildTx(instructions: TransactionInstruction[], payerPublicKey: PublicKey, blockhash: string, lookupTableAccounts?: AddressLookupTableAccount[]): VersionedTransaction;
 /**
  * Sends a versioned transaction and confirms it.
  *
@@ -36,15 +21,10 @@ export declare function buildTx(
  *
  * @return TransactionSignature
  */
-export declare function sendAndConfirmTx(
-    rpc: Rpc,
-    tx: VersionedTransaction,
-    confirmOptions?: ConfirmOptions,
-    blockHashCtx?: {
-        blockhash: string;
-        lastValidBlockHeight: number;
-    },
-): Promise<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.
  *
@@ -54,15 +34,10 @@ export declare function sendAndConfirmTx(
  * @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>>;
+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.
  *
@@ -74,10 +49,4 @@ export declare function confirmTx(
  * @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;
+export declare function buildAndSignTx(instructions: TransactionInstruction[], payer: Signer, blockhash: string, additionalSigners?: Signer[], lookupTableAccounts?: AddressLookupTableAccount[]): VersionedTransaction;

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

@@ -1,11 +1,8 @@
 import BN from 'bn.js';
-import {
-    CompressedAccount,
-    CompressedAccountWithMerkleContext,
-} from '../state';
+import { CompressedAccount, CompressedAccountWithMerkleContext } from '../state';
 export declare const validateSufficientBalance: (balance: BN) => void;
-export declare const validateSameOwner: (
-    compressedAccounts:
-        | CompressedAccount[]
-        | CompressedAccountWithMerkleContext[],
-) => void;
+export declare const validateSameOwner: (compressedAccounts: CompressedAccount[] | 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;