@lightprotocol/stateless.js 0.1.0-alpha.0

package/dist/types/instruction/pack-compressed-accounts.d.ts

@@ -0,0 +1,30 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+import { PackedCompressedAccountWithMerkleContext } from '../state';
+import { CompressedAccountWithMerkleContext } from '../state/compressed-account';
+/**
+ * @internal Finds the index of a PublicKey in an array, or adds it if not
+ * present
+ * */
+export declare function getIndexOrAdd(accountsArray: PublicKey[], key: PublicKey): number;
+/** @internal */
+export declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey[] | PublicKey | undefined, numberOfOutputCompressedAccounts: number, inputCompressedAccountsWithMerkleContext: CompressedAccountWithMerkleContext[]): PublicKey[];
+/**
+ * Packs Compressed Accounts.
+ *
+ * Replaces PublicKey with index pointer to remaining accounts.
+ *
+ * @param inputCompressedAccounts           ix input state to be consumed
+ * @param numberOfOutputCompressedAccounts  ix ouput state to be created
+ * @param outputStateMerkleTrees            State trees that the output should
+ *                                          be inserted into. Defaults to the
+ *                                          0th state tree of the input state.
+ *                                          Gets padded to the length of
+ *                                          outputCompressedAccounts.
+ * @param remainingAccounts                 Optional existing array of accounts
+ *                                          to append to.
+ **/
+export declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContext[], numberOfOutputCompressedAccounts: number, outputStateMerkleTrees?: PublicKey[] | PublicKey, remainingAccounts?: PublicKey[]): {
+    packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
+    outputStateMerkleTreeIndices: number[];
+    remainingAccountMetas: AccountMeta[];
+};

package/dist/types/programs/compressed-pda.d.ts

@@ -0,0 +1,148 @@
+import { Program, BN } from '@coral-xyz/anchor';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { PspCompressedPda } from '../idls/psp_compressed_pda';
+import { CompressedAccount, CompressedAccountWithMerkleContext, CompressedProof } from '../state';
+export declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
+/**
+ * Defines the parameters for the transfer method
+ */
+type TransferParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * The input state to be consumed.
+     */
+    inputCompressedAccounts: CompressedAccountWithMerkleContext[];
+    /**
+     * Recipient address
+     */
+    toAddress: PublicKey;
+    /**
+     * amount of lamports to transfer.
+     */
+    lamports: number | BN;
+    /**
+     * The recent state root indices of the input state. The expiry is tied to
+     * the proof.
+     *
+     * TODO: Add support for passing recent-values after instruction creation.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: CompressedProof;
+    /**
+     * The state trees that the tx output should be inserted into. This can be a
+     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
+     * of input state.
+     */
+    outputStateTrees?: PublicKey[] | PublicKey;
+};
+/**
+ * Defines the parameters for the transfer method
+ */
+type CompressParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * address that the lamports are attached to. also defaults to the recipient owner
+     */
+    toAddress: PublicKey;
+    /**
+     * amount of lamports to compress.
+     */
+    lamports: number | BN;
+    /**
+     * The state tree that the tx output should be inserted into. This can be a
+     *
+     */
+    outputStateTree: PublicKey;
+};
+/**
+ * Defines the parameters for the transfer method
+ */
+type DecompressParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * The input state to be consumed.
+     */
+    inputCompressedAccounts: CompressedAccountWithMerkleContext[];
+    /**
+     * Recipient address of uncompressed lamports
+     */
+    toAddress: PublicKey;
+    /**
+     * amount of lamports to decompress.
+     */
+    lamports: number | BN;
+    /**
+     * The recent state root indices of the input state. The expiry is tied to
+     * the proof.
+     *
+     * TODO: Add support for passing recent-values after instruction creation.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: CompressedProof;
+    /**
+     * The state trees that the tx output should be inserted into. This can be a
+     * single PublicKey or an array of PublicKey. Defaults to the 0th state tree
+     * of input state.
+     */
+    outputStateTree?: PublicKey;
+};
+export declare class LightSystemProgram {
+    /**
+     * @internal
+     */
+    constructor();
+    /**
+     * Public key that identifies the CompressedPda program
+     */
+    static programId: PublicKey;
+    private static _program;
+    static get program(): Program<PspCompressedPda>;
+    /**
+     * @internal
+     * Cwct1kQLwJm8Z3HetLu8m4SXkhD6FZ5fXbJQCxTxPnGY
+     */
+    static deriveCompressedSolPda(): PublicKey;
+    /**
+     * Initializes the program statically if not already initialized.
+     */
+    private static initializeProgram;
+    static createTransferOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], toAddress: PublicKey, lamports: number | BN): CompressedAccount[];
+    static createDecompressOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], lamports: number | BN): CompressedAccount[];
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static transfer(params: TransferParams): Promise<TransactionInstruction[]>;
+    /**
+     * Initialize the compressed sol pda
+     */
+    static initCompressedSolPda(feePayer: PublicKey): Promise<TransactionInstruction>;
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static compress(params: CompressParams): Promise<TransactionInstruction[]>;
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    static decompress(params: DecompressParams): Promise<TransactionInstruction[]>;
+}
+export {};

package/dist/types/programs/index.d.ts

@@ -0,0 +1 @@
+export * from './compressed-pda';

package/dist/types/rpc-interface.d.ts

@@ -0,0 +1,430 @@
+import { PublicKey, DataSizeFilter, MemcmpFilter } from '@solana/web3.js';
+import type { Struct } from 'superstruct';
+import { MerkleUpdateContext, BN254, CompressedProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData } from './state';
+import { BN } from '@coral-xyz/anchor';
+export type CompressedProofWithContext = {
+    compressedProof: CompressedProof;
+    roots: string[];
+    rootIndices: number[];
+    leafIndices: number[];
+    leaves: BN[];
+    merkleTree: PublicKey;
+    nullifierQueue: PublicKey;
+};
+export interface GetCompressedTokenAccountsByOwnerOrDelegateOptions {
+    mint?: PublicKey;
+    cursor?: string;
+    limit?: BN;
+}
+export type GetCompressedAccountsFilter = MemcmpFilter | DataSizeFilter;
+export type GetCompressedAccountConfig = {
+    encoding?: string;
+};
+export type GetCompressedAccountsConfig = {
+    encoding?: string;
+    filters?: GetCompressedAccountsFilter[];
+};
+export interface ParsedTokenAccount {
+    compressedAccount: CompressedAccountWithMerkleContext;
+    parsed: TokenData;
+}
+export type WithMerkleUpdateContext<T> = {
+    /** merkle update context */
+    context: MerkleUpdateContext | null;
+    /** response value */
+    value: T;
+};
+export type WithContext<T> = {
+    /** context */
+    context: {
+        slot: number;
+    };
+    /** response value */
+    value: T;
+};
+/**
+ * @internal
+ */
+export declare function createRpcResult<T, U>(result: Struct<T, U>): Struct<import("superstruct/dist/utils").Simplify<import("superstruct/dist/utils").Optionalize<{
+    jsonrpc: "2.0";
+    id: string;
+    result: T;
+}>> | {
+    jsonrpc: "2.0";
+    id: string;
+    error: {
+        message: string;
+        code: unknown;
+        data?: any;
+    };
+}, null>;
+/**
+ * @internal
+ */
+export declare function jsonRpcResult<T, U>(schema: Struct<T, U>): Struct<import("superstruct/dist/utils").Simplify<import("superstruct/dist/utils").Optionalize<{
+    jsonrpc: "2.0";
+    id: string;
+    result: T;
+}>> | {
+    jsonrpc: "2.0";
+    id: string;
+    error: {
+        message: string;
+        code: unknown;
+        data?: any;
+    };
+}, null>;
+/**
+ * @internal
+ */
+export declare function jsonRpcResultAndContext<T, U>(value: Struct<T, U>): Struct<import("superstruct/dist/utils").Simplify<import("superstruct/dist/utils").Optionalize<{
+    jsonrpc: "2.0";
+    id: string;
+    result: import("superstruct/dist/utils").Simplify<import("superstruct/dist/utils").Optionalize<{
+        context: {
+            slot: number;
+        };
+        value: T;
+    }>>;
+}>> | {
+    jsonrpc: "2.0";
+    id: string;
+    error: {
+        message: string;
+        code: unknown;
+        data?: any;
+    };
+}, null>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountResult: Struct<{
+    leafIndex: number;
+    owner: PublicKey;
+    lamports: BN;
+    address: PublicKey | null;
+    data: string | null;
+    discriminator: BN;
+    dataHash: BN | null;
+    hash: BN;
+    tree: PublicKey | null;
+    seq: BN | null;
+    slotUpdated: BN;
+}, {
+    hash: Struct<BN, null>;
+    address: Struct<PublicKey | null, null>;
+    data: Struct<string | null, null>;
+    dataHash: Struct<BN | null, null>;
+    discriminator: Struct<BN, null>;
+    owner: Struct<PublicKey, null>;
+    lamports: Struct<BN, null>;
+    tree: Struct<PublicKey | null, null>;
+    seq: Struct<BN | null, null>;
+    slotUpdated: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountResult: Struct<{
+    leafIndex: number;
+    owner: PublicKey;
+    lamports: BN;
+    address: PublicKey | null;
+    data: string | null;
+    discriminator: BN;
+    dataHash: BN | null;
+    frozen: boolean;
+    hash: BN;
+    tree: PublicKey;
+    seq: BN;
+    amount: BN;
+    delegate: PublicKey | null;
+    closeAuthority: PublicKey | null;
+    isNative: boolean;
+    mint: PublicKey;
+}, {
+    address: Struct<PublicKey | null, null>;
+    amount: Struct<BN, null>;
+    delegate: Struct<PublicKey | null, null>;
+    closeAuthority: Struct<PublicKey | null, null>;
+    isNative: Struct<boolean, null>;
+    frozen: Struct<boolean, null>;
+    mint: Struct<PublicKey, null>;
+    owner: Struct<PublicKey, null>;
+    hash: Struct<BN, null>;
+    data: Struct<string | null, null>;
+    dataHash: Struct<BN | null, null>;
+    discriminator: Struct<BN, null>;
+    lamports: Struct<BN, null>;
+    tree: Struct<PublicKey, null>;
+    seq: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleCompressedAccountsResult: Struct<{
+    items: {
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        hash: BN;
+        tree: PublicKey | null;
+        seq: BN | null;
+        slotUpdated: BN;
+    }[];
+}, {
+    items: Struct<{
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        hash: BN;
+        tree: PublicKey | null;
+        seq: BN | null;
+        slotUpdated: BN;
+    }[], Struct<{
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        hash: BN;
+        tree: PublicKey | null;
+        seq: BN | null;
+        slotUpdated: BN;
+    }, {
+        hash: Struct<BN, null>;
+        address: Struct<PublicKey | null, null>;
+        data: Struct<string | null, null>;
+        dataHash: Struct<BN | null, null>;
+        discriminator: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        lamports: Struct<BN, null>;
+        tree: Struct<PublicKey | null, null>;
+        seq: Struct<BN | null, null>;
+        slotUpdated: Struct<BN, null>;
+        leafIndex: Struct<number, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountsByOwnerResult: Struct<{
+    items: {
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        hash: BN;
+        tree: PublicKey | null;
+        seq: BN | null;
+        slotUpdated: BN;
+    }[];
+}, {
+    items: Struct<{
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        hash: BN;
+        tree: PublicKey | null;
+        seq: BN | null;
+        slotUpdated: BN;
+    }[], Struct<{
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        hash: BN;
+        tree: PublicKey | null;
+        seq: BN | null;
+        slotUpdated: BN;
+    }, {
+        hash: Struct<BN, null>;
+        address: Struct<PublicKey | null, null>;
+        data: Struct<string | null, null>;
+        dataHash: Struct<BN | null, null>;
+        discriminator: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        lamports: Struct<BN, null>;
+        tree: Struct<PublicKey | null, null>;
+        seq: Struct<BN | null, null>;
+        slotUpdated: Struct<BN, null>;
+        leafIndex: Struct<number, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
+    items: {
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        frozen: boolean;
+        hash: BN;
+        tree: PublicKey;
+        seq: BN;
+        amount: BN;
+        delegate: PublicKey | null;
+        closeAuthority: PublicKey | null;
+        isNative: boolean;
+        mint: PublicKey;
+    }[];
+}, {
+    items: Struct<{
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        frozen: boolean;
+        hash: BN;
+        tree: PublicKey;
+        seq: BN;
+        amount: BN;
+        delegate: PublicKey | null;
+        closeAuthority: PublicKey | null;
+        isNative: boolean;
+        mint: PublicKey;
+    }[], Struct<{
+        leafIndex: number;
+        owner: PublicKey;
+        lamports: BN;
+        address: PublicKey | null;
+        data: string | null;
+        discriminator: BN;
+        dataHash: BN | null;
+        frozen: boolean;
+        hash: BN;
+        tree: PublicKey;
+        seq: BN;
+        amount: BN;
+        delegate: PublicKey | null;
+        closeAuthority: PublicKey | null;
+        isNative: boolean;
+        mint: PublicKey;
+    }, {
+        address: Struct<PublicKey | null, null>;
+        amount: Struct<BN, null>;
+        delegate: Struct<PublicKey | null, null>;
+        closeAuthority: Struct<PublicKey | null, null>;
+        isNative: Struct<boolean, null>;
+        frozen: Struct<boolean, null>;
+        mint: Struct<PublicKey, null>;
+        owner: Struct<PublicKey, null>;
+        hash: Struct<BN, null>;
+        data: Struct<string | null, null>;
+        dataHash: Struct<BN | null, null>;
+        discriminator: Struct<BN, null>;
+        lamports: Struct<BN, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN, null>;
+        leafIndex: Struct<number, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const SlotResult: Struct<number, null>;
+/**
+ * @internal
+ */
+export declare const HealthResult: Struct<string, null>;
+/**
+ * @internal
+ */
+export declare const MerkeProofResult: Struct<{
+    leafIndex: number;
+    proof: BN[];
+    hash: BN;
+    merkleTree: PublicKey;
+}, {
+    hash: Struct<BN, null>;
+    merkleTree: Struct<PublicKey, null>;
+    leafIndex: Struct<number, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleMerkleProofsResult: Struct<{
+    leafIndex: number;
+    proof: BN[];
+    hash: BN;
+    merkleTree: PublicKey;
+}[], Struct<{
+    leafIndex: number;
+    proof: BN[];
+    hash: BN;
+    merkleTree: PublicKey;
+}, {
+    hash: Struct<BN, null>;
+    merkleTree: Struct<PublicKey, null>;
+    leafIndex: Struct<number, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+}>>;
+/**
+ * @internal
+ */
+export declare const BalanceResult: Struct<BN, null>;
+export declare const AccountProofResult: Struct<{
+    root: number[];
+    proof: number[][];
+    hash: number[];
+}, {
+    hash: Struct<number[], Struct<number, null>>;
+    root: Struct<number[], Struct<number, null>>;
+    proof: Struct<number[][], Struct<number[], Struct<number, null>>>;
+}>;
+export interface CompressionApiInterface {
+    /** Retrieve compressed account by hash or address */
+    getCompressedAccount(hash: BN254): Promise<CompressedAccountWithMerkleContext | null>;
+    /** Retrieve compressed account by hash or address */
+    getCompressedBalance(hash: BN254): Promise<BN | null>;
+    /** Retrieve merkle proof for a compressed account */
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
+    /** Retrieve compressed account by hash or address */
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[] | null>;
+    /** Retrieve multiple merkle proofs for compressed accounts */
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[] | null>;
+    /** Retrieve compressed accounts by owner */
+    getCompressedAccountsByOwner(owner: PublicKey): Promise<CompressedAccountWithMerkleContext[] | null>;
+    /** Receive validity Proof for n compressed accounts */
+    getValidityProof(hashes: BN254[]): Promise<CompressedProofWithContext>;
+    /** Retrieve health status of the node */
+    getHealth(): Promise<string>;
+    /** Retrieve the current slot */
+    getSlot(): Promise<number>;
+    getCompressedTokenAccountsByOwner(publicKey: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<ParsedTokenAccount[]>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<ParsedTokenAccount[]>;
+    getCompressedTokenAccountBalance(hash: BN254): Promise<{
+        amount: BN;
+    }>;
+}

package/dist/types/rpc.d.ts

@@ -0,0 +1,26 @@
+import { Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
+import { CompressedProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount } from './rpc-interface';
+import { MerkleContextWithMerkleProof, BN254, CompressedAccountWithMerkleContext } from './state';
+import { BN } from '@coral-xyz/anchor';
+export declare function createRpc(endpointOrWeb3JsConnection?: string | Connection, compressionApiEndpoint?: string, config?: ConnectionConfig): Rpc;
+export declare class Rpc extends Connection implements CompressionApiInterface {
+    compressionApiEndpoint: string;
+    constructor(endpoint: string, compressionApiEndpoint: string, proverEndpoint?: string, config?: ConnectionConfig);
+    getCompressedAccount(hash: BN254): Promise<CompressedAccountWithMerkleContext | null>;
+    getCompressedBalance(hash: BN254): Promise<BN | null>;
+    /** Retrieve the merkle proof for a compressed account */
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[] | null>;
+    /** Retrieve the merkle proof for a compressed account */
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[] | null>;
+    getCompressedAccountsByOwner(owner: PublicKey): Promise<CompressedAccountWithMerkleContext[]>;
+    getValidityProof(hashes: BN254[]): Promise<CompressedProofWithContext>;
+    getHealth(): Promise<string>;
+    /** TODO: use from Connection */
+    getSlot(): Promise<number>;
+    getCompressedTokenAccountsByOwner(owner: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<ParsedTokenAccount[]>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options?: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<ParsedTokenAccount[]>;
+    getCompressedTokenAccountBalance(hash: BN254): Promise<{
+        amount: BN;
+    }>;
+}

package/dist/types/state/BN254.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { PublicKey } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+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. Fills up to 32 bytes. */
+export declare function encodeBN254toBase58(bigintNumber: BN254, pad?: number): string;
+/** Convert Base58 string to <254-bit Solana Public key*/
+export declare function bigint254ToPublicKey(bigintNumber: BN254): PublicKey;
+/** Convert Solana Public key to <254-bit bigint */
+export declare function PublicKeyToBN254(publicKey: PublicKey): BN254;

package/dist/types/state/compressed-account.d.ts

@@ -0,0 +1,35 @@
+import { BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { CompressedAccount, CompressedAccountData } from './types';
+import { BN254 } from './BN254';
+export type CompressedAccountWithMerkleContext = CompressedAccount & MerkleContext;
+/**
+ * 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 MerkleUpdateContext = {
+    /** Context slot */
+    slot: number;
+    /** Slot that the compressed account was appended at */
+    slotCreated?: number;
+    /** Sequence */
+    seq?: 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;
+};
+export declare const createCompressedAccount: (owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: PublicKey) => CompressedAccount;
+export declare const createCompressedAccountWithMerkleContext: (merkleContext: MerkleContext, owner: PublicKey, lamports?: BN, data?: CompressedAccountData, address?: PublicKey) => CompressedAccountWithMerkleContext;
+export declare const createMerkleContext: (merkleTree: PublicKey, nullifierQueue: PublicKey, hash: number[], leafIndex: number) => MerkleContext;

package/dist/types/state/index.d.ts

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