@lightprotocol/stateless.js 0.17.2-alpha.0 → 0.17.2-alpha.2

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

@@ -1,40 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-import BN from 'bn.js';
-import { Rpc } from '../../rpc';
-import { ParsedTokenAccount, WithCursor } from '../../rpc-interface';
-import { CompressedAccount, PublicTransactionEvent } from '../../state';
-import { Layout } from '@coral-xyz/borsh';
-type TokenData = {
-    mint: PublicKey;
-    owner: PublicKey;
-    amount: BN;
-    delegate: PublicKey | null;
-    state: number;
-    tlv: Buffer | null;
-};
-export declare const TokenDataLayout: Layout<TokenData>;
-export type EventWithParsedTokenTlvData = {
-    inputCompressedAccountHashes: number[][];
-    outputCompressedAccounts: ParsedTokenAccount[];
-};
-/**
- * Manually parse the compressed token layout for a given compressed account.
- * @param compressedAccount - The compressed account
- * @returns The parsed token data
- */
-export declare function parseTokenLayoutWithIdl(compressedAccount: CompressedAccount, programId?: PublicKey): TokenData | null;
-/**
- * Retrieves all compressed token accounts for a given mint and owner.
- *
- * Note: This function is intended for testing purposes only. For production, use rpc.getCompressedTokenAccounts.
- *
- * @param events    Public transaction events
- * @param owner     PublicKey of the token owner
- * @param mint      PublicKey of the token mint
- */
-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 {};

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

@@ -1,13 +0,0 @@
-import { ParsedTransactionWithMeta } from '@solana/web3.js';
-import { Rpc } from '../../rpc';
-import { PublicTransactionEvent } from '../../state';
-type Deserializer<T> = (data: Buffer, tx: ParsedTransactionWithMeta) => T;
-/**
- * @internal
- * 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 {};

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

@@ -1,3 +0,0 @@
-export * from './test-rpc';
-export * from './get-parsed-events';
-export * from './get-compressed-token-accounts';

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

@@ -1,250 +0,0 @@
-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 { MerkleContextWithNewAddressProof, Rpc } from '../../rpc';
-export interface TestRpcConfig {
-    /**
-     * Address of the state tree to index. Default: public default test state
-     * tree.
-     */
-    merkleTreeAddress?: PublicKey;
-    /**
-     * Nullifier queue associated with merkleTreeAddress
-     */
-    nullifierQueueAddress?: PublicKey;
-    /**
-     * Depth of state tree. Defaults to the public default test state tree depth
-     */
-    depth?: number;
-    /**
-     * Log proof generation time
-     */
-    log?: boolean;
-    /**
-     * Address of the address tree to index. Default: public default test
-     * address tree.
-     */
-    addressTreeAddress?: PublicKey;
-    /**
-     * Address queue associated with addressTreeAddress
-     */
-    addressQueueAddress?: PublicKey;
-}
-export type ClientSubscriptionId = number;
-export interface LightWasm {
-    blakeHash(input: string | Uint8Array, hashLength: number): Uint8Array;
-    poseidonHash(input: string[] | BN[]): Uint8Array;
-    poseidonHashString(input: string[] | BN[]): string;
-    poseidonHashBN(input: string[] | BN[]): BN;
-}
-/**
- * Returns a mock RPC instance for use in unit tests.
- *
- * @param lightWasm               Wasm hasher instance.
- * @param endpoint                RPC endpoint URL. Defaults to
- *                                'http://127.0.0.1:8899'.
- * @param proverEndpoint          Prover server endpoint URL. Defaults to
- *                                'http://localhost:3001'.
- * @param merkleTreeAddress       Address of the merkle tree to index. Defaults
- *                                to the public default test state tree.
- * @param nullifierQueueAddress   Optional address of the associated nullifier
- *                                queue.
- * @param depth                   Depth of the merkle tree.
- * @param log                     Log proof generation time.
- */
-export declare function getTestRpc(lightWasm: LightWasm, endpoint?: string, compressionApiEndpoint?: string, proverEndpoint?: string, merkleTreeAddress?: PublicKey, nullifierQueueAddress?: PublicKey, depth?: number, log?: boolean): Promise<Rpc>;
-/**
- * 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.
- * Constraints:
- * - Can only index 1 merkletree
- * - Can only index up to 1000 transactions
- *
- * For advanced testing use photon: https://github.com/helius-labs/photon
- */
-export declare class TestRpc extends Connection implements CompressionApiInterface {
-    connection: Connection;
-    compressionApiEndpoint: string;
-    proverEndpoint: string;
-    merkleTreeAddress: PublicKey;
-    nullifierQueueAddress: PublicKey;
-    addressTreeAddress: PublicKey;
-    addressQueueAddress: PublicKey;
-    lightWasm: LightWasm;
-    depth: number;
-    log: boolean;
-    /**
-     * Establish a Compression-compatible JSON RPC mock-connection
-     *
-     * @param endpoint                  endpoint to the solana cluster (use for
-     *                                  localnet only)
-     * @param hasher                    light wasm hasher instance
-     * @param compressionApiEndpoint    Endpoint to the compression server.
-     * @param proverEndpoint            Endpoint to the prover server. defaults
-     *                                  to endpoint
-     * @param connectionConfig          Optional connection config
-     * @param testRpcConfig             Config for the mock rpc
-     */
-    constructor(endpoint: string, hasher: LightWasm, compressionApiEndpoint: string, proverEndpoint: string, connectionConfig?: ConnectionConfig, testRpcConfig?: TestRpcConfig);
-    /**
-     * Fetch the compressed account for the specified account hash
-     */
-    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
-    /**
-     * Fetch the compressed balance for the specified account hash
-     */
-    getCompressedBalance(address?: BN254, hash?: BN254): Promise<BN>;
-    /**
-     * Fetch the total compressed balance for the specified owner public key
-     */
-    getCompressedBalanceByOwner(owner: PublicKey): Promise<BN>;
-    /**
-     * Fetch the latest merkle proof for the specified account hash from the
-     * cluster
-     */
-    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
-    /**
-     * Fetch all the account info for multiple compressed accounts specified by
-     * an array of account hashes
-     */
-    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
-    /**
-     * Ensure that the Compression Indexer has already indexed the transaction
-     */
-    confirmTransactionIndexed(_slot: number): Promise<boolean>;
-    /**
-     * Fetch the latest merkle proofs for multiple compressed accounts specified
-     * by an array account hashes
-     */
-    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
-    /**
-     * Fetch all the compressed accounts owned by the specified public key.
-     * Owner can be a program or user account
-     */
-    getCompressedAccountsByOwner(owner: PublicKey, _config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
-    /**
-     * Fetch the latest compression signatures on the cluster. Results are
-     * paginated.
-     */
-    getLatestCompressionSignatures(_cursor?: string, _limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
-    /**
-     * Fetch the latest non-voting signatures on the cluster. Results are
-     * not paginated.
-     */
-    getLatestNonVotingSignatures(_limit?: number): Promise<LatestNonVotingSignatures>;
-    /**
-     * Fetch all the compressed token accounts owned by the specified public
-     * key. Owner can be a program or user account
-     */
-    getCompressedTokenAccountsByOwner(owner: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
-    /**
-     * Fetch all the compressed accounts delegated to the specified public key.
-     */
-    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
-    /**
-     * Fetch the compressed token balance for the specified account hash
-     */
-    getCompressedTokenAccountBalance(hash: BN254): Promise<{
-        amount: BN;
-    }>;
-    /**
-     * @deprecated use {@link getCompressedTokenBalancesByOwnerV2}.
-     * Fetch all the compressed token balances owned by the specified public
-     * key. Can filter by mint.
-     */
-    getCompressedTokenBalancesByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<{
-        balance: BN;
-        mint: PublicKey;
-    }[]>>;
-    /**
-     * Fetch all the compressed token balances owned by the specified public
-     * key. Can filter by mint. Uses context.
-     */
-    getCompressedTokenBalancesByOwnerV2(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
-    /**
-     * Returns confirmed signatures for transactions involving the specified
-     * account hash forward in time from genesis to the most recent confirmed
-     * block
-     *
-     * @param hash queried account hash
-     */
-    getCompressionSignaturesForAccount(_hash: BN254): Promise<SignatureWithMetadata[]>;
-    /**
-     * Fetch a confirmed or finalized transaction from the cluster. Return with
-     * CompressionInfo
-     */
-    getTransactionWithCompressionInfo(_signature: string): Promise<CompressedTransaction | 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[]>>;
-    /**
-     * Returns confirmed signatures for compression transactions involving the
-     * specified account owner forward in time from genesis to the
-     * most recent confirmed block
-     *
-     * @param owner queried owner public key
-     */
-    getCompressionSignaturesForOwner(_owner: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
-    /**
-     * Returns confirmed signatures for compression transactions involving the
-     * specified token account owner forward in time from genesis to the most
-     * recent confirmed block
-     */
-    getCompressionSignaturesForTokenOwner(_owner: PublicKey, _options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
-    /**
-     * Fetch the current indexer health status
-     */
-    getIndexerHealth(): Promise<string>;
-    /**
-     * Fetch the current slot that the node is processing
-     */
-    getIndexerSlot(): Promise<number>;
-    /**
-     * Fetch the latest address proofs for new unique addresses specified by an
-     * array of addresses.
-     *
-     * the proof states that said address have not yet been created in respective address tree.
-     * @param addresses Array of BN254 new addresses
-     * @returns Array of validity proofs for new addresses
-     */
-    getMultipleNewAddressProofs(addresses: BN254[]): Promise<MerkleContextWithNewAddressProof[]>;
-    getCompressedMintTokenHolders(_mint: PublicKey, _options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
-    /**
-     * Advanced usage of getValidityProof: fetches ZKP directly from a custom
-     * non-rpcprover. Note: This uses the proverEndpoint specified in the
-     * constructor. For normal usage, please use {@link getValidityProof}
-     * instead.
-     *
-     * Note: Use RPC class for forested trees. TestRpc is only for custom
-     * testing purposes.
-     */
-    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>>;
-    /**
-     * Fetch the latest validity proof for (1) compressed accounts specified by
-     * an array of account hashes. (2) new unique addresses specified by an
-     * array of addresses.
-     *
-     * Validity proofs prove the presence of compressed accounts in state trees
-     * and the non-existence of addresses in address trees, respectively. They
-     * enable verification without recomputing the merkle proof path, thus
-     * lowering verification and data costs.
-     *
-     * @param hashes        Array of BN254 hashes.
-     * @param newAddresses  Array of BN254 new addresses.
-     * @returns             validity proof with context
-     */
-    getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<CompressedProofWithContext>;
-    getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<CompressedProofWithContext>;
-}

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

@@ -1,63 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-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.
- *
- * @param seed                     Seed to derive the address from
- * @param addressMerkleTreePubkey  Merkle tree public key. Defaults to
- *                                 defaultTestStateTreeAccounts().addressTree
- * @returns                        Derived address
- */
-export declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
-export interface NewAddressParams {
-    /**
-     * Seed for the compressed account. Must be seed used to derive
-     * newAccountAddress
-     */
-    seed: Uint8Array;
-    /**
-     * Recent state root index of the address tree. The expiry is tied to the
-     * validity proof.
-     */
-    addressMerkleTreeRootIndex: number;
-    /**
-     * Address tree pubkey. Must be base pubkey used to derive new address
-     */
-    addressMerkleTreePubkey: PublicKey;
-    /**
-     * Address space queue pubkey. Associated with the state tree.
-     */
-    addressQueuePubkey: PublicKey;
-}
-export interface NewAddressParamsPacked {
-    /**
-     * Seed for the compressed account. Must be seed used to derive
-     * newAccountAddress
-     */
-    seed: number[];
-    /**
-     * Recent state root index of the address tree. The expiry is tied to the
-     * validity proof.
-     */
-    addressMerkleTreeRootIndex: number;
-    /**
-     * Index of the address merkle tree account in the remaining accounts array
-     */
-    addressMerkleTreeAccountIndex: number;
-    /**
-     * Index of the address queue account in the remaining accounts array
-     */
-    addressQueueAccountIndex: number;
-}
-/**
- * Packs new address params for instruction data in TypeScript clients
- *
- * @param newAddressParams      New address params
- * @param remainingAccounts     Remaining accounts
- * @returns                     Packed new address params
- */
-export declare function packNewAddressParams(newAddressParams: NewAddressParams[], remainingAccounts: PublicKey[]): {
-    newAddressParamsPacked: NewAddressParamsPacked[];
-    remainingAccounts: PublicKey[];
-};

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

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

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

@@ -1,7 +0,0 @@
-/**
- * @param targetLamports - Target priority fee in lamports
- * @param computeUnits - Expected compute units used by the transaction
- * @returns microLamports per compute unit (use in
- * `ComputeBudgetProgram.setComputeUnitPrice`)
- */
-export declare function calculateComputeUnitPrice(targetLamports: number, computeUnits: number): number;

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

@@ -1,31 +0,0 @@
-import { Buffer } from 'buffer';
-import { Keypair } from '@solana/web3.js';
-import BN from 'bn.js';
-export declare function byteArrayToKeypair(byteArray: number[]): Keypair;
-/**
- * @internal
- * convert BN to hex with '0x' prefix
- */
-export declare function toHex(bn: BN): string;
-export declare const toArray: <T>(value: T | T[]) => T[];
-export declare const bufToDecStr: (buf: Buffer) => string;
-/**
- * Hash the provided `bytes` with Keccak256 and ensure the result fits in the
- * BN254 prime field by repeatedly hashing the inputs with various "bump seeds"
- * and truncating the resulting hash to 31 bytes.
- *
- * @deprecated Use `hashvToBn254FieldSizeBe` instead.
- */
-export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number] | null;
-/**
- * Hash the provided `bytes` with Keccak256 and ensure that the result fits in
- * the BN254 prime field by truncating the resulting hash to 31 bytes.
- *
- * @param bytes Input bytes
- *
- * @returns     Hash digest
- */
-export declare function hashvToBn254FieldSizeBe(bytes: Uint8Array[]): Uint8Array;
-/** Mutates array in place */
-export declare function pushUniqueItems<T>(items: T[], map: T[]): void;
-export declare function toCamelCase(obj: Array<any> | unknown | any): Array<any> | unknown | any;

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

@@ -1,10 +0,0 @@
-export * from './address';
-export * from './airdrop';
-export * from './conversion';
-export * from './parse-validity-proof';
-export * from './pipe';
-export * from './send-and-confirm';
-export * from './sleep';
-export * from './test-utils';
-export * from './validation';
-export * from './calculate-compute-unit-price';

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

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

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

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-import { Connection, Keypair, Signer } from '@solana/web3.js';
-import { Rpc } from '../rpc';
-export declare const ALICE: Keypair;
-export declare const BOB: Keypair;
-export declare const CHARLIE: Keypair;
-export declare const DAVE: Keypair;
-/**
- * Create a new account and airdrop lamports to it
- *
- * @param rpc       connection to use
- * @param lamports  amount of lamports to airdrop
- * @param counter   counter to use for generating the keypair.
- *                  If undefined or >255, generates random keypair.
- */
-export declare function newAccountWithLamports(rpc: Rpc, lamports?: number, counter?: number | undefined): Promise<Signer>;
-export declare function getConnection(): Connection;
-/**
- * For use in tests.
- * Generate a unique keypair by passing in a counter <255. If no counter
- * is supplied, it uses and increments a global counter.
- * if counter > 255, generates random keypair
- */
-export declare function getTestKeypair(counter?: number | undefined): Keypair;

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

@@ -1,4 +0,0 @@
-import BN from 'bn.js';
-import { CompressedAccount, CompressedAccountWithMerkleContext } from '../state';
-export declare const validateSufficientBalance: (balance: BN) => void;
-export declare const validateSameOwner: (compressedAccounts: CompressedAccount[] | CompressedAccountWithMerkleContext[]) => void;