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

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

@@ -1,8 +1,9 @@
-import { AccountInfo, Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
+import { AccountInfo, Commitment, Connection, ConnectionConfig, GetAccountInfoConfig, PublicKey, SignaturesForAddressOptions } from '@solana/web3.js';
 import { Buffer } from 'buffer';
-import { ValidityProofWithContext, CompressedTransaction, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, HexInputsForProver, ParsedTokenAccount, SignatureWithMetadata, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, WithContext, GetCompressedAccountsByOwnerConfig, WithCursor, AddressWithTree, HashWithTree, CompressedMintTokenHolders, TokenBalance, PaginatedOptions } from './rpc-interface';
+import { ValidityProofWithContext, CompressedTransaction, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, HexInputsForProver, ParsedTokenAccount, SignatureWithMetadata, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, WithContext, GetCompressedAccountsByOwnerConfig, WithCursor, AddressWithTree, HashWithTree, CompressedMintTokenHolders, TokenBalance, PaginatedOptions, DerivationMode, AddressWithTreeInfoV2, SignaturesForAddressInterfaceResult, UnifiedSignatureInfo, UnifiedTokenBalance, UnifiedBalance } from './rpc-interface';
 import { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext, ValidityProof, AddressTreeInfo, MerkleContext } from './state';
 import BN from 'bn.js';
+import { ConfirmedSignatureInfo } from '@solana/web3.js';
 import { LightWasm } from './test-helpers';
 import { TreeInfo } from './state/types';
 /** @internal */
@@ -72,6 +73,12 @@ export interface NullifierMetadata {
     nullifier: BN254;
     txHash: BN254;
 }
+/**
+ * Merge signatures from Solana RPC and compression indexer.
+ * Deduplicates by signature, tracking sources in the `sources` array.
+ * When a signature exists in both, uses Solana data (richer) but marks both sources.
+ */
+export declare function mergeSignatures(solanaSignatures: ConfirmedSignatureInfo[], compressedSignatures: SignatureWithMetadata[]): UnifiedSignatureInfo[];
 /**
  *
  */
@@ -100,6 +107,10 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @internal
      */
     doFetch(): Promise<TreeInfo[]>;
+    /**
+     * Get a V2 address tree info.
+     */
+    getAddressTreeInfoV2(): Promise<TreeInfo>;
     /**
      * Fetch the compressed account for the specified account address or hash
      */
@@ -260,6 +271,17 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      * @returns             validity proof with context
      */
     getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    /**
+     * Fetch the latest validity proof for (1) compressed accounts specified by
+     * an array of account Merkle contexts, and (2) new unique addresses specified by
+     * an array of address objects with tree info.
+     *
+     * 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.
+     */
+    getValidityProofV2(accountMerkleContexts?: (MerkleContext | undefined)[], newAddresses?: AddressWithTreeInfoV2[], derivationMode?: DerivationMode): Promise<ValidityProofWithContext>;
     /**
      * Fetch the latest validity proof for (1) compressed accounts specified by
      * an array of account hashes. (2) new unique addresses specified by an
@@ -278,17 +300,62 @@ export declare class Rpc extends Connection implements CompressionApiInterface {
      */
     getValidityProofAndRpcContext(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
     /**
-     * Get account info from either compressed or onchain storage.
-     * @param address         The account address to fetch.
-     * @param programId       The owner program ID.
-     * @param addressTreeInfo The address tree info used to store the account.
-     * @param rpc             The RPC client to use.
+     * Fetch the account info for the specified public key. Returns metadata
+     * to load in case the account is cold.
+     * @param address               The account address to fetch.
+     * @param programId             The owner program ID.
+     * @param commitmentOrConfig    Optional. The commitment or config to use
+     *                              for the onchain account fetch.
+     * @param addressSpace          Optional. The address space info that was
+     *                              used at init.
      *
-     * @returns               Account info with compression info, or null if account
-     *                        doesn't exist.
-     */
-    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: Rpc): Promise<{
+     * @returns                     Account info with load info, or null if
+     *                              account doesn't exist. LoadContext is always
+     *                              some if the account is compressible. isCold
+     *                              indicates the current state of the account,
+     *                              if true the account must referenced in a
+     *                              load instruction before use.
+     */
+    getAccountInfoInterface(address: PublicKey, programId: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig, addressSpace?: TreeInfo): Promise<{
         accountInfo: AccountInfo<Buffer>;
-        merkleContext?: MerkleContext;
+        isCold: boolean;
+        loadContext?: MerkleContext;
     } | null>;
+    /**
+     * Get signatures for an address from both Solana and compression indexer.
+     *
+     * @param address               Address to fetch signatures for.
+     * @param options               Options for the Solana getSignaturesForAddress call.
+     * @param compressedOptions     Options for the compression getCompressionSignaturesForAddress call.
+     * @returns                     Unified signatures from both sources.
+     */
+    getSignaturesForAddressInterface(address: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    /**
+     * Get signatures for an owner from both Solana and compression indexer.
+     *
+     * @param owner                 Owner address to fetch signatures for.
+     * @param options               Options for the Solana getSignaturesForAddress call.
+     * @param compressedOptions     Options for the compression getCompressionSignaturesForOwner call.
+     * @returns                     Unified signatures from both sources.
+     */
+    getSignaturesForOwnerInterface(owner: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    /**
+     * Get token account balance for an address, regardless of whether the token
+     * account is hot or cold.
+     *
+     * @param address       Token account address.
+     * @param owner         Owner public key.
+     * @param mint          Mint public key.
+     * @param commitment    Commitment level for on-chain query.
+     * @returns             Unified token balance from both sources.
+     */
+    getTokenAccountBalanceInterface(address: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment): Promise<UnifiedTokenBalance>;
+    /**
+     * Get SOL balance for an address, regardless of whether the account is hot or cold.
+     *
+     * @param address       Address to fetch balance for.
+     * @param commitment    Commitment level for on-chain query.
+     * @returns             Unified SOL balance.
+     */
+    getBalanceInterface(address: PublicKey, commitment?: Commitment): Promise<UnifiedBalance>;
 }

package/dist/cjs/node/test-helpers/test-rpc/get-compressed-token-accounts.d.ts

@@ -3,7 +3,6 @@ import BN from 'bn.js';
 import { Rpc } from '../../rpc';
 import { ParsedTokenAccount, WithCursor } from '../../rpc-interface';
 import { PublicTransactionEvent, CompressedAccountLegacy } from '../../state';
-import { Layout } from '@coral-xyz/borsh';
 type TokenData = {
     mint: PublicKey;
     owner: PublicKey;
@@ -12,7 +11,6 @@ type TokenData = {
     state: number;
     tlv: Buffer | null;
 };
-export declare const TokenDataLayout: Layout<TokenData>;
 export type EventWithParsedTokenTlvData = {
     inputCompressedAccountHashes: number[][];
     outputCompressedAccounts: ParsedTokenAccount[];

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

@@ -1,8 +1,8 @@
-import { AccountInfo, Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
+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 { ValidityProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
-import { BN254, CompressedAccountWithMerkleContext, MerkleContext, MerkleContextWithMerkleProof } from '../../state';
+import { BN254, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof } from '../../state';
 import { MerkleContextWithNewAddressProof } from '../../rpc';
 import { TreeInfo } from '../../state/types';
 export interface TestRpcConfig {
@@ -83,6 +83,10 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      */
     getStateTreeInfos(): Promise<TreeInfo[]>;
     doFetch(): Promise<TreeInfo[]>;
+    /**
+     * Get a V2 address tree info.
+     */
+    getAddressTreeInfoV2(): Promise<TreeInfo>;
     /**
      * Fetch the compressed account for the specified account hash
      */
@@ -232,8 +236,10 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      */
     getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
-    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: TestRpc): Promise<{
-        accountInfo: AccountInfo<Buffer>;
-        merkleContext?: MerkleContext;
-    } | null>;
+    getValidityProofV2(accountMerkleContexts?: any[], newAddresses?: any[], derivationMode?: any): Promise<ValidityProofWithContext>;
+    getAccountInfoInterface(_address: PublicKey, _programId: PublicKey, _addressSpaceInfo: any): Promise<any>;
+    getSignaturesForAddressInterface(_address: PublicKey, _options?: any, _compressedOptions?: PaginatedOptions): Promise<any>;
+    getSignaturesForOwnerInterface(_owner: PublicKey, _options?: any, _compressedOptions?: PaginatedOptions): Promise<any>;
+    getTokenAccountBalanceInterface(_address: PublicKey, _owner: PublicKey, _mint: PublicKey, _commitment?: any): Promise<any>;
+    getBalanceInterface(_address: PublicKey, _commitment?: any): Promise<any>;
 }

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

@@ -1,28 +1,16 @@
 import { PublicKey } from '@solana/web3.js';
-/**
- * Derive an address for a compressed account from a seed and an address Merkle
- * tree public key.
- *
- * @param seed                     32 bytes seed to derive the address from
- * @param addressMerkleTreePubkey  Address Merkle tree public key as bytes.
- * @param programIdBytes           Program ID bytes.
- * @returns                        Derived address as bytes
- */
-export declare function deriveAddressV2(seed: Uint8Array, addressMerkleTreePubkey: Uint8Array, programIdBytes: Uint8Array): Uint8Array;
-export declare function hashVWithBumpSeed(bytes: Uint8Array[]): Uint8Array;
 export declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
+export declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
+export declare function deriveAddressSeedV2(seeds: Uint8Array[]): Uint8Array;
 /**
- * @deprecated Use {@link deriveAddressV2} instead, unless you're using v1.
- *
- * Derive an address for a compressed account from a seed and an address Merkle
- * tree public key.
+ * Derives an address from a seed using the v2 method (matching Rust's derive_address_from_seed)
  *
- * @param seed                     Seed to derive the address from
- * @param addressMerkleTreePubkey  Merkle tree public key. Defaults to
- *                                 defaultTestStateTreeAccounts().addressTree
+ * @param addressSeed              The address seed (32 bytes)
+ * @param addressMerkleTreePubkey  Merkle tree public key
+ * @param programId                Program ID
  * @returns                        Derived address
  */
-export declare function deriveAddress(seed: Uint8Array, addressMerkleTreePubkey?: PublicKey): PublicKey;
+export declare function deriveAddressV2(addressSeed: Uint8Array, addressMerkleTreePubkey: PublicKey, programId: PublicKey): PublicKey;
 export interface NewAddressParams {
     /**
      * Seed for the compressed account. Must be seed used to derive

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

@@ -21,8 +21,8 @@ export declare const toCamelCase: (object: any) => any;
  * @deprecated Use `hashvToBn254FieldSizeBe` instead.
  */
 export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number] | null;
+export declare function hashvToBn254FieldSizeBeU8Array(bytes: Uint8Array[]): Uint8Array;
 /**
- * TODO: make consistent with latest rust. (use u8::max bumpseed)
  * 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.
  *

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

@@ -1,6 +1,21 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { TreeInfo, TreeType } from '../state/types';
+import { MerkleContext } from '../state/compressed-account';
 import { StateTreeLUTPair } from '../constants';
+/**
+ * Get the currently active output queue from a merkle context.
+ *
+ * @param merkleContext The merkle context to get the output queue from
+ * @returns The output queue public key
+ */
+export declare function getOutputQueue(merkleContext: MerkleContext): PublicKey;
+/**
+ * Get the currently active output tree info from a merkle context.
+ *
+ * @param merkleContext The merkle context to get the output tree info from
+ * @returns The output tree info
+ */
+export declare function getOutputTreeInfo(merkleContext: MerkleContext): TreeInfo;
 /**
  * @deprecated use {@link getTreeInfoByPubkey} instead
  */

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

@@ -3,6 +3,7 @@ export * from './airdrop';
 export * from './calculate-compute-unit-price';
 export * from './conversion';
 export * from './dedupe-signer';
+export * from './instruction';
 export * from './parse-validity-proof';
 export * from './pipe';
 export * from './send-and-confirm';
@@ -10,4 +11,4 @@ export * from './sleep';
 export * from './validation';
 export * from './state-tree-lookup-table';
 export * from './get-state-tree-infos';
-export * from './packed-accounts';
+export * from './pack-decompress';

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

@@ -0,0 +1,35 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+export declare class PackedAccounts {
+    private preAccounts;
+    private systemAccounts;
+    private nextIndex;
+    private map;
+    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccounts;
+    static newWithSystemAccountsV2(config: SystemAccountMetaConfig): PackedAccounts;
+    addPreAccountsSigner(pubkey: PublicKey): void;
+    addPreAccountsSignerMut(pubkey: PublicKey): void;
+    addPreAccountsMeta(accountMeta: AccountMeta): void;
+    addSystemAccounts(config: SystemAccountMetaConfig): void;
+    addSystemAccountsV2(config: SystemAccountMetaConfig): void;
+    insertOrGet(pubkey: PublicKey): number;
+    insertOrGetReadOnly(pubkey: PublicKey): number;
+    insertOrGetConfig(pubkey: PublicKey, isSigner: boolean, isWritable: boolean): number;
+    private hashSetAccountsToMetas;
+    private getOffsets;
+    toAccountMetas(): {
+        remainingAccounts: AccountMeta[];
+        systemStart: number;
+        packedStart: number;
+    };
+}
+export declare class SystemAccountMetaConfig {
+    selfProgram: PublicKey;
+    cpiContext?: PublicKey;
+    solCompressionRecipient?: PublicKey;
+    solPoolPda?: PublicKey;
+    private constructor();
+    static new(selfProgram: PublicKey): SystemAccountMetaConfig;
+    static newWithCpiContext(selfProgram: PublicKey, cpiContext: PublicKey): SystemAccountMetaConfig;
+}
+export declare function getLightSystemAccountMetas(config: SystemAccountMetaConfig): AccountMeta[];
+export declare function getLightSystemAccountMetasV2(config: SystemAccountMetaConfig): AccountMeta[];

package/dist/cjs/node/utils/pack-decompress.d.ts

@@ -0,0 +1,31 @@
+import { PublicKey, AccountMeta } from '@solana/web3.js';
+import { ValidityProof } from '../state';
+import { TreeInfo } from '../state/types';
+export interface AccountDataWithTreeInfo {
+    key: string;
+    data: any;
+    treeInfo: TreeInfo;
+}
+export interface PackedDecompressResult {
+    proofOption: {
+        0: ValidityProof | null;
+    };
+    compressedAccounts: any[];
+    systemAccountsOffset: number;
+    remainingAccounts: AccountMeta[];
+}
+/**
+ * Pack accounts and proof for decompressAccountsIdempotent instruction.
+ * This function prepares compressed account data, validity proof, and remaining accounts
+ * for idempotent decompression operations.
+ *
+ * @param programId - The program ID
+ * @param proof - The validity proof with context
+ * @param accountsData - Array of account data with tree info
+ * @param addresses - Array of account addresses
+ * @returns Packed instruction parameters
+ */
+export declare function packDecompressAccountsIdempotent(programId: PublicKey, proof: {
+    compressedProof: ValidityProof | null;
+    treeInfos: TreeInfo[];
+}, accountsData: AccountDataWithTreeInfo[], addresses: PublicKey[]): Promise<PackedDecompressResult>;

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

@@ -0,0 +1,18 @@
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+import BN from 'bn.js';
+import { TreeInfo } from '../state';
+/**
+ * Compress lamports to a solana address
+ *
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param lamports              Amount of lamports to compress
+ * @param toAddress             Address of the recipient compressed account
+ * @param outputStateTreeInfo   Optional output state tree. If not provided,
+ *                              fetches a random active state tree.
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+export declare function compress(rpc: Rpc, payer: Signer, lamports: number | BN, toAddress: PublicKey, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

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

@@ -0,0 +1,38 @@
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+import { AddressTreeInfo, TreeInfo } from '../state';
+import BN from 'bn.js';
+/**
+ * Create compressed account with address
+ *
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param seeds                 Seeds to derive the new account address
+ * @param programId             Owner of the new account
+ * @param addressTreeInfo       Optional address tree info. Defaults to a current
+ *                              shared address tree.
+ * @param outputStateTreeInfo   Optional output state tree. Defaults to fetching
+ *                              a current shared state tree.
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+export declare function createAccount(rpc: Rpc, payer: Signer, seeds: Uint8Array[], programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+/**
+ * Create compressed account with address and lamports
+ *
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param seeds                 Seeds to derive the new account address
+ * @param lamports              Number of compressed lamports to initialize the
+ *                              account with
+ * @param programId             Owner of the new account
+ * @param addressTreeInfo       Optional address tree info. Defaults to a
+ *                              current shared address tree.
+ * @param outputStateTreeInfo   Optional output state tree. Defaults to a
+ *                              current shared state tree.
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+export declare function createAccountWithLamports(rpc: Rpc, payer: Signer, seeds: Uint8Array[], lamports: number | BN, programId: PublicKey, addressTreeInfo?: AddressTreeInfo, outputStateTreeInfo?: TreeInfo, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

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

@@ -0,0 +1,15 @@
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+import BN from 'bn.js';
+/**
+ * Decompress lamports into a solana account
+ *
+ * @param rpc                   RPC to use
+ * @param payer                 Payer of the transaction and initialization fees
+ * @param lamports              Amount of lamports to compress
+ * @param toAddress             Address of the recipient compressed account
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Transaction signature
+ */
+export declare function decompress(rpc: Rpc, payer: Signer, lamports: number | BN, recipient: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

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

@@ -0,0 +1,5 @@
+export * from './compress';
+export * from './create-account';
+export * from './decompress';
+export * from '../utils/dedupe-signer';
+export * from './transfer';

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

@@ -0,0 +1,16 @@
+import { ConfirmOptions, PublicKey, Signer, TransactionSignature } from '@solana/web3.js';
+import BN from 'bn.js';
+import { Rpc } from '../rpc';
+/**
+ * Transfer compressed lamports from one owner to another
+ *
+ * @param rpc                   Rpc to use
+ * @param payer                 Payer of transaction fees
+ * @param lamports              Number of lamports to transfer
+ * @param owner                 Owner of the compressed lamports
+ * @param toAddress             Destination address of the recipient
+ * @param confirmOptions        Options for confirming the transaction
+ *
+ * @return Signature of the confirmed transaction
+ */
+export declare function transfer(rpc: Rpc, payer: Signer, lamports: number | BN, owner: Signer, toAddress: PublicKey, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;

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

@@ -0,0 +1,176 @@
+import BN from 'bn.js';
+import { Buffer } from 'buffer';
+import { ConfirmOptions, PublicKey } from '@solana/web3.js';
+import { TreeInfo, TreeType } from './state/types';
+export declare enum VERSION {
+    V1 = "V1",
+    V2 = "V2"
+}
+/**
+/**
+ * @internal
+ * Feature flags. Only use if you know what you are doing.
+ */
+export declare const featureFlags: {
+    version: VERSION;
+    isV2: () => boolean;
+};
+/**
+ * Returns the correct endpoint name for the current API version. E.g.
+ * versionedEndpoint('getCompressedAccount') -> 'getCompressedAccount' (V1)
+ * or 'getCompressedAccountV2' (V2)
+ */
+export declare const versionedEndpoint: (base: string) => string;
+export declare const FIELD_SIZE: BN;
+export declare const HIGHEST_ADDRESS_PLUS_ONE: BN;
+export declare const COMPUTE_BUDGET_PATTERN: number[];
+export declare const INVOKE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INVOKE_CPI_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INVOKE_CPI_WITH_READ_ONLY_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INVOKE_CPI_WITH_ACCOUNT_INFO_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const INSERT_INTO_QUEUES_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export declare const noopProgram = "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV";
+export declare const lightSystemProgram = "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7";
+export declare const accountCompressionProgram = "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq";
+export declare const getRegisteredProgramPda: () => PublicKey;
+export declare const getAccountCompressionAuthority: () => PublicKey;
+export declare const defaultStaticAccounts: () => PublicKey[];
+export declare const defaultStaticAccountsStruct: () => {
+    registeredProgramPda: PublicKey;
+    noopProgram: PublicKey;
+    accountCompressionProgram: PublicKey;
+    accountCompressionAuthority: PublicKey;
+    cpiSignatureAccount: null;
+};
+export type StateTreeLUTPair = {
+    stateTreeLookupTable: PublicKey;
+    nullifyLookupTable: PublicKey;
+};
+/**
+ * Returns the Default Public State Tree LUTs for Devnet and Mainnet-Beta.
+ */
+export declare const defaultStateTreeLookupTables: () => {
+    mainnet: StateTreeLUTPair[];
+    devnet: StateTreeLUTPair[];
+};
+/**
+ * @internal
+ */
+export declare const isLocalTest: (url: string) => boolean;
+/**
+ * @internal
+ */
+export declare const localTestActiveStateTreeInfos: () => TreeInfo[];
+export declare const getDefaultAddressSpace: () => {
+    tree: PublicKey;
+    queue: PublicKey;
+    cpiContext: undefined;
+    treeType: TreeType;
+    nextTreeInfo: null;
+};
+export declare const getDefaultAddressTreeInfo: () => {
+    tree: PublicKey;
+    queue: PublicKey;
+    cpiContext: undefined;
+    treeType: TreeType;
+    nextTreeInfo: null;
+};
+export declare const getBatchAddressTreeInfo: () => {
+    tree: PublicKey;
+    queue: PublicKey;
+    cpiContext: undefined;
+    treeType: TreeType;
+    nextTreeInfo: null;
+};
+/**
+ * @deprecated use {@link rpc.getStateTreeInfos} and {@link selectStateTreeInfo} instead.
+ * for address trees, use {@link getDefaultAddressTreeInfo} instead.
+ * Use only with Localnet testing.
+ * For public networks, fetch via {@link defaultStateTreeLookupTables} and {@link getAllStateTreeInfos}.
+ */
+export declare const defaultTestStateTreeAccounts: () => {
+    nullifierQueue: PublicKey;
+    merkleTree: PublicKey;
+    merkleTreeHeight: number;
+    addressTree: PublicKey;
+    addressQueue: PublicKey;
+};
+/**
+ * @internal testing only
+ */
+export declare const defaultTestStateTreeAccounts2: () => {
+    nullifierQueue2: PublicKey;
+    merkleTree2: PublicKey;
+};
+export declare const COMPRESSED_TOKEN_PROGRAM_ID: PublicKey;
+export declare const CTOKEN_PROGRAM_ID: PublicKey;
+export declare const stateTreeLookupTableMainnet = "7i86eQs3GSqHjN47WdWLTCGMW6gde1q96G2EVnUyK2st";
+export declare const nullifiedStateTreeLookupTableMainnet = "H9QD4u1fG7KmkAzn2tDXhheushxFe1EcrjGGyEFXeMqT";
+export declare const stateTreeLookupTableDevnet = "Dk9mNkbiZXJZ4By8DfSP6HEE4ojZzRvucwpawLeuwq8q";
+export declare const nullifiedStateTreeLookupTableDevnet = "AXbHzp1NgjLvpfnD6JRTTovXZ7APUCdtWZFCRr5tCxse";
+export declare const nullifierQueuePubkey = "nfq1NvQDJ2GEgnS8zt9prAe8rjjpAW1zFkrvZoBR148";
+export declare const cpiContextPubkey = "cpi1uHzrEhBG733DoEJNgHCyRS3XmmyVNZx5fonubE4";
+export declare const merkletreePubkey = "smt1NamzXdq4AMqS2fS2F1i5KTYPZRhoHgWx38d8WsT";
+export declare const addressTree = "amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2";
+export declare const addressQueue = "aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F";
+export declare const merkleTree2Pubkey = "smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho";
+export declare const nullifierQueue2Pubkey = "nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X";
+export declare const cpiContext2Pubkey = "cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK";
+export declare const batchMerkleTree1 = "bmt1LryLZUMmF7ZtqESaw7wifBXLfXHQYoE4GAmrahU";
+export declare const batchQueue1 = "oq1na8gojfdUhsfCpyjNt6h4JaDWtHf1yQj4koBWfto";
+export declare const batchCpiContext1 = "cpi15BoVPKgEPw5o8wc2T816GE7b378nMXnhH3Xbq4y";
+export declare const batchMerkleTree2 = "bmt2UxoBxB9xWev4BkLvkGdapsz6sZGkzViPNph7VFi";
+export declare const batchQueue2 = "oq2UkeMsJLfXt2QHzim242SUi3nvjJs8Pn7Eac9H9vg";
+export declare const batchCpiContext2 = "cpi2yGapXUR3As5SjnHBAVvmApNiLsbeZpF3euWnW6B";
+export declare const batchMerkleTree3 = "bmt3ccLd4bqSVZVeCJnH1F6C8jNygAhaDfxDwePyyGb";
+export declare const batchQueue3 = "oq3AxjekBWgo64gpauB6QtuZNesuv19xrhaC1ZM1THQ";
+export declare const batchCpiContext3 = "cpi3mbwMpSX8FAGMZVP85AwxqCaQMfEk9Em1v8QK9Rf";
+export declare const batchMerkleTree4 = "bmt4d3p1a4YQgk9PeZv5s4DBUmbF5NxqYpk9HGjQsd8";
+export declare const batchQueue4 = "oq4ypwvVGzCUMoiKKHWh4S1SgZJ9vCvKpcz6RT6A8dq";
+export declare const batchCpiContext4 = "cpi4yyPDc4bCgHAnsenunGA8Y77j3XEDyjgfyCKgcoc";
+export declare const batchMerkleTree5 = "bmt5yU97jC88YXTuSukYHa8Z5Bi2ZDUtmzfkDTA2mG2";
+export declare const batchQueue5 = "oq5oh5ZR3yGomuQgFduNDzjtGvVWfDRGLuDVjv9a96P";
+export declare const batchCpiContext5 = "cpi5ZTjdgYpZ1Xr7B1cMLLUE81oTtJbNNAyKary2nV6";
+export declare const batchAddressTree = "amt2kaJA14v3urZbZvnc5v2np8jqvc4Z8zDep5wbtzx";
+export declare const testBatchAddressTree = "EzKE84aVTkCUhDHLELqyJaq1Y7UVVmqxXqZjVHwHY3rK";
+export declare const batchMerkleTree = "bmt1LryLZUMmF7ZtqESaw7wifBXLfXHQYoE4GAmrahU";
+export declare const batchQueue = "oq1na8gojfdUhsfCpyjNt6h4JaDWtHf1yQj4koBWfto";
+export declare const confirmConfig: ConfirmOptions;
+export declare const DEFAULT_MERKLE_TREE_HEIGHT = 26;
+export declare const DEFAULT_MERKLE_TREE_ROOTS = 2800;
+/** Threshold (per asset) at which new in-UTXOs get merged, in order to reduce UTXO pool size */
+export declare const UTXO_MERGE_THRESHOLD = 20;
+export declare const UTXO_MERGE_MAXIMUM = 10;
+/**
+ * Treshold after which the currently used transaction Merkle tree is switched
+ * to the next one
+ */
+export declare const TRANSACTION_MERKLE_TREE_ROLLOVER_THRESHOLD: BN;
+/**
+ * Fee to provide continous funding for the state Merkle tree.
+ * Once the state Merkle tree is at 95% capacity the accumulated fees
+ * will be used to fund the next state Merkle tree with the same parameters.
+ *
+ * Is charged per output compressed account.
+ */
+export declare const STATE_MERKLE_TREE_ROLLOVER_FEE: BN;
+/**
+ * Fee to provide continous funding for the address queue and address Merkle tree.
+ * Once the address Merkle tree is at 95% capacity the accumulated fees
+ * will be used to fund the next address queue and address tree with the same parameters.
+ *
+ * Is charged per newly created address.
+ */
+export declare const ADDRESS_QUEUE_ROLLOVER_FEE: BN;
+/**
+ * Is charged if the transaction nullifies at least one compressed account.
+ */
+export declare const STATE_MERKLE_TREE_NETWORK_FEE: BN;
+/**
+ * Is charged per address the transaction creates.
+ */
+export declare const ADDRESS_TREE_NETWORK_FEE_V1: BN;
+/**
+ * Is charged per address the transaction creates.
+ */
+export declare const ADDRESS_TREE_NETWORK_FEE_V2: BN;