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

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

@@ -1,275 +0,0 @@
-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 BN from 'bn.js';
-/** @internal */
-export declare function parseAccountData({ discriminator, data, dataHash, }: {
-    discriminator: BN;
-    data: string;
-    dataHash: BN;
-}): {
-    discriminator: number[];
-    data: Buffer;
-    dataHash: number[];
-};
-/**
- * Establish a Compression-compatible JSON RPC connection
- *
- * @param endpointOrWeb3JsConnection    endpoint to the solana cluster or
- *                                      Connection object
- * @param compressionApiEndpoint        Endpoint to the compression server
- * @param proverEndpoint                Endpoint to the prover server. defaults
- *                                      to endpoint
- * @param connectionConfig              Optional connection config
- */
-export declare function createRpc(endpointOrWeb3JsConnection?: string | Connection, compressionApiEndpoint?: string, proverEndpoint?: string, config?: ConnectionConfig): Rpc;
-/** @internal */
-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 type NonInclusionMerkleProofInputs = {
-    root: BN;
-    value: BN;
-    leaf_lower_range_value: BN;
-    leaf_higher_range_value: BN;
-    nextIndex: BN;
-    merkle_proof_hashed_indexed_element_leaf: BN[];
-    index_hashed_indexed_element_leaf: BN;
-};
-export type MerkleContextWithNewAddressProof = {
-    root: BN;
-    rootIndex: number;
-    value: BN;
-    leafLowerRangeValue: BN;
-    leafHigherRangeValue: BN;
-    nextIndex: BN;
-    merkleProofHashedIndexedElementLeaf: BN[];
-    indexHashedIndexedElementLeaf: BN;
-    merkleTree: PublicKey;
-    nullifierQueue: PublicKey;
-};
-export type NonInclusionJsonStruct = {
-    root: string;
-    value: string;
-    pathIndex: number;
-    pathElements: string[];
-    leafLowerRangeValue: string;
-    leafHigherRangeValue: string;
-    nextIndex: number;
-};
-export declare function convertMerkleProofsWithContextToHex(merkleProofsWithContext: MerkleContextWithMerkleProof[]): HexInputsForProver[];
-export declare function convertNonInclusionMerkleProofInputsToHex(nonInclusionMerkleProofInputs: MerkleContextWithNewAddressProof[]): NonInclusionJsonStruct[];
-import { LightWasm } from './test-helpers';
-export declare function getPublicInputHash(accountProofs: MerkleContextWithMerkleProof[], accountHashes: BN254[], newAddressProofs: MerkleContextWithNewAddressProof[], lightWasm: LightWasm): BN;
-/**
- *
- */
-export declare class Rpc extends Connection implements CompressionApiInterface {
-    compressionApiEndpoint: string;
-    proverEndpoint: string;
-    /**
-     * Establish a Compression-compatible JSON RPC connection
-     *
-     * @param endpoint                      Endpoint to the solana cluster
-     * @param compressionApiEndpoint        Endpoint to the compression server
-     * @param proverEndpoint                Endpoint to the prover server.
-     * @param connectionConfig              Optional connection config
-     */
-    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint: string, config?: ConnectionConfig);
-    /**
-     * Fetch the compressed account for the specified account address or hash
-     */
-    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
-    /**
-     * Fetch the compressed balance for the specified account address or 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[]>;
-    /**
-     * 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 | 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[]>>;
-    /**
-     * 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} instead.
-     *
-     * 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[]>>;
-    /**
-     * 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[]>>>;
-    /**
-     * Returns confirmed compression 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>;
-    /**
-     * Ensure that the Compression Indexer has already indexed the transaction
-     */
-    confirmTransactionIndexed(slot: number): Promise<boolean>;
-    /**
-     * Fetch the current slot that the node is processing
-     */
-    getIndexerSlot(): Promise<number>;
-    /**
-     * Fetch all the compressed token holders for a given mint. Paginated.
-     */
-    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>;
-    /**
-     * Fetch all non-voting signatures
-     */
-    getLatestNonVotingSignatures(limit?: number, cursor?: string): Promise<LatestNonVotingSignatures>;
-    /**
-     * 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[]>;
-    /**
-     * 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.
-     *
-     * 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
-     */
-    getValidityProofDirect(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
-     * 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>;
-    /**
-     * 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 { hash: BN254, tree: PublicKey, queue: PublicKey }.
-     * @param newAddresses  Array of { address: BN254, tree: PublicKey, queue: PublicKey }.
-     * @returns             validity proof with context
-     */
-    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
-     * array of addresses. Returns with context slot.
-     *
-     * 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. Optionally specify the
-     *                      tree and queue for each address. Default to public
-     *                      state tree/queue.
-     * @returns             validity proof with context
-     */
-    getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<CompressedProofWithContext>>;
-}

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

@@ -1,14 +0,0 @@
-import BN from 'bn.js';
-import { Buffer } from 'buffer';
-/**
- * bignumber with <254-bit max size. Anchor serialization doesn't support native
- * bigint yet, so we wrap BN. This wrapper has simple base10 encoding which is
- * needed for zk circuit compat, in addition to the base58 encoding that users
- * 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;
-/** 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;
-/** Convert <254-bit bigint to Base58 string.  */
-export declare function encodeBN254toBase58(bigintNumber: BN): string;

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

@@ -1,31 +0,0 @@
-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;
-};
-/**
- * Context for compressed account inserted into a state Merkle tree
- * */
-export type MerkleContext = {
-    /** State Merkle tree */
-    merkleTree: PublicKey;
-    /** The state nullfier queue belonging to merkleTree */
-    nullifierQueue: PublicKey;
-    /** Poseidon hash of the utxo preimage. Is a leaf in state merkle tree  */
-    hash: number[];
-    /** 'hash' position within the Merkle tree */
-    leafIndex: number;
-};
-export type MerkleContextWithMerkleProof = MerkleContext & {
-    /** Recent valid 'hash' proof path, expires after n slots */
-    merkleProof: BN254[];
-    /** Index of state root the merkleproof is valid for, expires after n slots */
-    rootIndex: number;
-    /** 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;

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

@@ -1,3 +0,0 @@
-export * from './BN254';
-export * from './compressed-account';
-export * from './types';

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

@@ -1,91 +0,0 @@
-import BN from 'bn.js';
-import { PublicKey } from '@solana/web3.js';
-import { Buffer } from 'buffer';
-import { NewAddressParamsPacked } from '../utils';
-export interface PackedCompressedAccountWithMerkleContext {
-    compressedAccount: CompressedAccount;
-    merkleContext: PackedMerkleContext;
-    rootIndex: number;
-    readOnly: boolean;
-}
-export interface PackedMerkleContext {
-    merkleTreePubkeyIndex: number;
-    nullifierQueuePubkeyIndex: number;
-    leafIndex: number;
-    queueIndex: null | QueueIndex;
-}
-export interface QueueIndex {
-    queueId: number;
-    index: number;
-}
-/**
- * Describe the generic compressed account details applicable to every
- * compressed account.
- * */
-export interface CompressedAccount {
-    /** Public key of program or user that owns the account */
-    owner: PublicKey;
-    /** Lamports attached to the account */
-    lamports: BN;
-    /**
-     * TODO: use PublicKey. Optional unique account ID that is persistent across
-     * transactions.
-     */
-    address: number[] | null;
-    /** Optional data attached to the account */
-    data: CompressedAccountData | null;
-}
-/**
- * Describe the generic compressed account details applicable to every
- * compressed account.
- * */
-export interface OutputCompressedAccountWithPackedContext {
-    compressedAccount: CompressedAccount;
-    merkleTreeIndex: number;
-}
-export interface CompressedAccountData {
-    discriminator: number[];
-    data: Buffer;
-    dataHash: number[];
-}
-export interface PublicTransactionEvent {
-    inputCompressedAccountHashes: number[][];
-    outputCompressedAccountHashes: number[][];
-    outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
-    outputLeafIndices: number[];
-    relayFee: BN | null;
-    isCompress: boolean;
-    compressOrDecompressLamports: BN | null;
-    pubkeyArray: PublicKey[];
-    message: Uint8Array | null;
-}
-export interface InstructionDataInvoke {
-    proof: CompressedProof | null;
-    inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
-    outputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
-    relayFee: BN | null;
-    newAddressParams: NewAddressParamsPacked[];
-    compressOrDecompressLamports: BN | null;
-    isCompress: boolean;
-}
-export interface CompressedProof {
-    a: number[];
-    b: number[];
-    c: number[];
-}
-export interface InputTokenDataWithContext {
-    amount: BN;
-    delegateIndex: number | null;
-    merkleContext: PackedMerkleContext;
-    rootIndex: number;
-    lamports: BN | null;
-    tlv: Buffer | null;
-}
-export type TokenData = {
-    mint: PublicKey;
-    owner: PublicKey;
-    amount: BN;
-    delegate: PublicKey | null;
-    state: number;
-    tlv: Buffer | null;
-};

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

@@ -1,2 +0,0 @@
-export * from './merkle-tree';
-export * from './test-rpc';

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

@@ -1,2 +0,0 @@
-export * from './indexed-array';
-export * from './merkle-tree';

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

@@ -1,85 +0,0 @@
-import { LightWasm } from '../test-rpc/test-rpc';
-import BN from 'bn.js';
-export declare class IndexedElement {
-    index: number;
-    value: BN;
-    nextIndex: number;
-    constructor(index: number, value: BN, nextIndex: number);
-    equals(other: IndexedElement): boolean;
-    compareTo(other: IndexedElement): number;
-    hash(lightWasm: LightWasm, nextValue: BN): Uint8Array;
-}
-export declare class IndexedElementBundle {
-    newLowElement: IndexedElement;
-    newElement: IndexedElement;
-    newElementNextValue: BN;
-    constructor(newLowElement: IndexedElement, newElement: IndexedElement, newElementNextValue: BN);
-}
-/**
- * This indexed array implementation mirrors the rust implementation of the
- * indexed merkle tree. It stores the elements of the indexed merkle tree.
- */
-export declare class IndexedArray {
-    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;
-    isEmpty(): boolean;
-    findElement(value: BN): IndexedElement | undefined;
-    init(): IndexedElementBundle;
-    /**
-     * Finds the index of the low element for the given `value` which should not be part of the array.
-     * Low element is the greatest element which still has a lower value than the provided one.
-     * Low elements are used in non-membership proofs.
-     */
-    findLowElementIndex(value: BN): number | undefined;
-    /**
-     * Returns the low element for the given value and the next value for that low element.
-     * Low element is the greatest element which still has lower value than the provided one.
-     * Low elements are used in non-membership proofs.
-     */
-    findLowElement(value: BN): [IndexedElement | undefined, BN | undefined];
-    /**
-     * Returns the hash of the given element. That hash consists of:
-     * - The value of the given element.
-     * - The `nextIndex` of the given element.
-     * - The value of the element pointed by `nextIndex`.
-     */
-    hashElement(lightWasm: LightWasm, index: number): Uint8Array | undefined;
-    /**
-     * Appends a new element with the given value to the indexed array.
-     * It finds the low element index and uses it to append the new element correctly.
-     * @param value The value of the new element to append.
-     * @returns The new element and its low element after insertion.
-     */
-    append(value: BN): IndexedElementBundle;
-    /**
-     * Appends a new element with the given value to the indexed array using a specific low element index.
-     * This method ensures the new element is placed correctly relative to the low element.
-     * @param lowElementIndex The index of the low element.
-     * @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;
-    /**
-     * Finds the lowest element in the array.
-     * @returns The lowest element or undefined if the array is empty.
-     */
-    lowest(): IndexedElement | undefined;
-    /**
-     * Creates a new element with the specified value and updates the low element index accordingly.
-     * @param lowElementIndex The index of the low element.
-     * @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;
-    /**
-     * Creates a new element with the specified value by first finding the appropriate low element index.
-     * @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.
-     */
-    newElement(value: BN): IndexedElementBundle;
-}

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

@@ -1,92 +0,0 @@
-import { LightWasm } from '../test-rpc/test-rpc';
-export declare const DEFAULT_ZERO = "0";
-/**
- * @callback hashFunction
- * @param left Left leaf
- * @param right Right leaf
- */
-/**
- * Merkle tree
- */
-export declare class MerkleTree {
-    /**
-     * Constructor
-     * @param {number} levels Number of levels in the tree
-     * @param {Array} [elements] Initial elements
-     * @param {Object} options
-     * @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
-     * @param [options.zeroElement] Value for non-existent leaves
-     */
-    levels: number;
-    capacity: number;
-    zeroElement: string;
-    _zeros: string[];
-    _layers: string[][];
-    _lightWasm: LightWasm;
-    constructor(levels: number, lightWasm: LightWasm, elements?: string[], { zeroElement }?: {
-        zeroElement?: string | undefined;
-    });
-    _rebuild(): void;
-    /**
-     * Get tree root
-     * @returns {*}
-     */
-    root(): string;
-    /**
-     * Insert new element into the tree
-     * @param element Element to insert
-     */
-    insert(element: string): void;
-    /**
-     * Insert multiple elements into the tree. Tree will be fully rebuilt during this operation.
-     * @param {Array} elements Elements to insert
-     */
-    bulkInsert(elements: string[]): void;
-    /**
-     * Change an element in the tree
-     * @param {number} index Index of element to change
-     * @param element Updated element value
-     */
-    update(index: number, element: string): void;
-    /**
-     * Get merkle path to a leaf
-     * @param {number} index Leaf index to generate path for
-     * @returns {{pathElements: number[], pathIndex: number[]}} An object containing adjacent elements and left-right index
-     */
-    path(index: number): {
-        pathElements: string[];
-        pathIndices: number[];
-    };
-    /**
-     * Find an element in the tree
-     * @param element An element to find
-     * @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;
-    /**
-     * Returns a copy of non-zero tree elements
-     * @returns {Object[]}
-     */
-    elements(): string[];
-    /**
-     * Serialize entire tree state including intermediate layers into a plain object
-     * Deserializing it back will not require to recompute any hashes
-     * Elements are not converted to a plain type, this is responsibility of the caller
-     */
-    serialize(): {
-        levels: number;
-        _zeros: string[];
-        _layers: string[][];
-    };
-    /**
-     * Deserialize data into a MerkleTree instance
-     * Make sure to provide the same hashFunction as was used in the source tree,
-     * otherwise the tree state will be invalid
-     *
-     * @param data
-     * @param hashFunction
-     * @returns {MerkleTree}
-     */
-    static deserialize(data: any, hashFunction: (left: string, right: string) => string): any;
-}

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

@@ -1,7 +0,0 @@
-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[]>;

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';