@lightprotocol/stateless.js 0.16.0 → 0.17.1

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 '@coral-xyz/anchor';
-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';
 export interface TestRpcConfig {
     /**
@@ -75,16 +53,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.
@@ -94,10 +63,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;
@@ -119,21 +85,11 @@ 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);
     /**
      * 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
      */
@@ -146,16 +102,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
      */
@@ -164,47 +116,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
      */
@@ -216,25 +152,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
@@ -242,16 +168,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
@@ -259,10 +181,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
@@ -270,19 +189,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
      */
@@ -299,13 +212,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
@@ -315,18 +223,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
@@ -341,12 +243,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/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

@@ -16,9 +16,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 +25,7 @@ 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;
+export declare function toCamelCase(obj: Array<any> | unknown | any): Array<any> | unknown | any;

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/test-utils.d.ts

@@ -12,11 +12,7 @@ export declare const DAVE: Keypair;
  * @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/validation.d.ts

@@ -1,11 +1,4 @@
 import { BN } from '@coral-xyz/anchor';
-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;

package/dist/cjs/node/wallet/interface.d.ts

@@ -1,9 +1,4 @@
-import {
-    Commitment,
-    Connection,
-    Keypair,
-    VersionedTransaction,
-} from '@solana/web3.js';
+import { Commitment, Connection, Keypair, VersionedTransaction } from '@solana/web3.js';
 import { PublicKey, Transaction } from '@solana/web3.js';
 export type InclusionProofPublicInputs = {
     root: string;
@@ -14,8 +9,7 @@ export type InclusionProofPrivateInputs = {
     leaf: string;
     leafIndex: string;
 };
-export type InclusionProofInputs = (InclusionProofPublicInputs &
-    InclusionProofPrivateInputs)[];
+export type InclusionProofInputs = (InclusionProofPublicInputs & InclusionProofPrivateInputs)[];
 export declare class Wallet {
     _publicKey: PublicKey;
     _keypair: Keypair;
@@ -25,12 +19,7 @@ export declare class Wallet {
     constructor(keypair: Keypair, url: string, commitment: Commitment);
     signTransaction: (tx: any) => Promise<any>;
     sendTransaction: (transaction: VersionedTransaction) => Promise<string>;
-    signAllTransactions: <T extends Transaction | VersionedTransaction>(
-        transactions: T[],
-    ) => Promise<T[]>;
+    signAllTransactions: <T extends Transaction | VersionedTransaction>(transactions: T[]) => Promise<T[]>;
     signMessage: (message: Uint8Array) => Promise<Uint8Array>;
-    sendAndConfirmTransaction: (
-        transaction: Transaction,
-        signers?: never[],
-    ) => Promise<any>;
+    sendAndConfirmTransaction: (transaction: Transaction, signers?: never[]) => Promise<any>;
 }

package/dist/cjs/node/wallet/use-wallet.d.ts

@@ -1,24 +1,9 @@
 import { Keypair, Commitment } from '@solana/web3.js';
-export declare const useWallet: (
-    keypair: Keypair,
-    url?: string,
-    commitment?: Commitment,
-) => {
-    publicKey: import('@solana/web3.js').PublicKey;
-    sendAndConfirmTransaction: (
-        transaction: import('@solana/web3.js').Transaction,
-        signers?: never[],
-    ) => Promise<any>;
+export declare const useWallet: (keypair: Keypair, url?: string, commitment?: Commitment) => {
+    publicKey: import("@solana/web3.js").PublicKey;
+    sendAndConfirmTransaction: (transaction: import("@solana/web3.js").Transaction, signers?: never[]) => Promise<any>;
     signMessage: (message: Uint8Array) => Promise<Uint8Array>;
     signTransaction: (tx: any) => Promise<any>;
-    signAllTransactions: <
-        T extends
-            | import('@solana/web3.js').Transaction
-            | import('@solana/web3.js').VersionedTransaction,
-    >(
-        transactions: T[],
-    ) => Promise<T[]>;
-    sendTransaction: (
-        transaction: import('@solana/web3.js').VersionedTransaction,
-    ) => Promise<string>;
+    signAllTransactions: <T extends import("@solana/web3.js").Transaction | import("@solana/web3.js").VersionedTransaction>(transactions: T[]) => Promise<T[]>;
+    sendTransaction: (transaction: import("@solana/web3.js").VersionedTransaction) => Promise<string>;
 };

package/dist/es/browser/actions/common.d.ts

@@ -1,6 +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[];
+export declare function dedupeSigner(signer: Signer, signers: Signer[]): Signer[];

package/dist/es/browser/actions/compress.d.ts

@@ -1,9 +1,4 @@
-import {
-    ConfirmOptions,
-    PublicKey,
-    Signer,
-    TransactionSignature,
-} from '@solana/web3.js';
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
 import { Rpc } from '../rpc';
 import { BN } from '@coral-xyz/anchor';
 /**
@@ -18,11 +13,4 @@ import { BN } from '@coral-xyz/anchor';
  *
  * @return Transaction signature
  */
-export declare function compress(
-    rpc: Rpc,
-    payer: Signer,
-    lamports: number | BN,
-    toAddress: PublicKey,
-    outputStateTree?: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+export declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

package/dist/es/browser/actions/create-account.d.ts

@@ -1,9 +1,4 @@
-import {
-    ConfirmOptions,
-    PublicKey,
-    Signer,
-    TransactionSignature,
-} from '@solana/web3.js';
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
 import { Rpc } from '../rpc';
 import { BN } from '@coral-xyz/anchor';
 /**
@@ -23,16 +18,7 @@ import { BN } from '@coral-xyz/anchor';
  *
  * @return                  Transaction signature
  */
-export declare function createAccount(
-    rpc: Rpc,
-    payer: Signer,
-    seeds: Uint8Array[],
-    programId: PublicKey,
-    addressTree?: PublicKey,
-    addressQueue?: PublicKey,
-    outputStateTree?: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+export declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTree?: PublicKey, addressQueue?: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
 /**
  * Create compressed account with address and lamports
  *
@@ -52,14 +38,4 @@ export declare function createAccount(
  *
  * @return                  Transaction signature
  */
-export declare function createAccountWithLamports(
-    rpc: Rpc,
-    payer: Signer,
-    seeds: Uint8Array[],
-    lamports: number | BN,
-    programId: PublicKey,
-    addressTree?: PublicKey,
-    addressQueue?: PublicKey,
-    outputStateTree?: PublicKey,
-    confirmOptions?: ConfirmOptions,
-): Promise<TransactionSignature>;
+export declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTree?: PublicKey, addressQueue?: PublicKey, outputStateTree?: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;