@lightprotocol/stateless.js 0.1.0-alpha.0

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

@@ -0,0 +1,108 @@
+/// <reference types="node" />
+import { BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+export interface PackedCompressedAccountWithMerkleContext {
+    compressedAccount: CompressedAccount;
+    merkleTreePubkeyIndex: number;
+    nullifierQueuePubkeyIndex: number;
+    leafIndex: 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: Implement address functionality. Optional unique account ID that is
+     * persistent across transactions.
+     */
+    address: PublicKey | null;
+    /** Optional data attached to the account */
+    data: CompressedAccountData | null;
+}
+export interface CompressedAccountData {
+    discriminator: number[];
+    data: Buffer;
+    dataHash: number[];
+}
+export interface PublicTransactionEvent {
+    inputCompressedAccountHashes: number[][];
+    outputCompressedAccountHashes: number[][];
+    inputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
+    outputCompressedAccounts: CompressedAccount[];
+    outputStateMerkleTreeAccountIndices: Uint8Array;
+    outputLeafIndices: number[];
+    relayFee: BN | null;
+    isCompress: boolean;
+    deCompressLamports: BN | null;
+    pubkeyArray: PublicKey[];
+    message: Uint8Array | null;
+}
+export interface InstructionDataTransfer {
+    proof: CompressedProof | null;
+    inputRootIndices: number[];
+    inputCompressedAccountsWithMerkleContext: PackedCompressedAccountWithMerkleContext[];
+    outputCompressedAccounts: CompressedAccount[];
+    outputStateMerkleTreeAccountIndices: Buffer;
+    relayFee: BN | null;
+    deCompressLamports: BN | null;
+    isCompression: boolean;
+    newAddressParams: NewAddressParamsPacked[];
+}
+export interface NewAddressParamsPacked {
+    seed: number[];
+    addressQueueAccountIndex: number;
+    addressMerkleTreeAccountIndex: number;
+    addressMerkleTreeRootIndex: number;
+}
+export interface CompressedProof {
+    a: number[];
+    b: number[];
+    c: number[];
+}
+/**
+ * Compressed-token types
+ *
+ * TODO: Token-related code should ideally not have to go into stateless.js.
+ * Find a better altnerative way to extend the RPC.
+ *
+ */
+export type TokenTransferOutputData = {
+    owner: PublicKey;
+    amount: BN;
+    lamports: BN | null;
+};
+export type CompressedTokenInstructionDataTransfer = {
+    proof: CompressedProof | null;
+    rootIndices: number[];
+    mint: PublicKey;
+    signerIsDelegate: boolean;
+    inputTokenDataWithContext: InputTokenDataWithContext[];
+    outputCompressedAccounts: TokenTransferOutputData[];
+    outputStateMerkleTreeAccountIndices: Buffer;
+    pubkeyArray: PublicKey[];
+    isCompress: boolean;
+    compressionAmount: BN | null;
+};
+export interface InputTokenDataWithContext {
+    amount: BN;
+    delegateIndex: number | null;
+    delegatedAmount: BN | null;
+    isNative: BN | null;
+    merkleTreePubkeyIndex: number;
+    nullifierQueuePubkeyIndex: number;
+    leafIndex: number;
+}
+export type TokenData = {
+    mint: PublicKey;
+    owner: PublicKey;
+    amount: BN;
+    delegate: PublicKey | null;
+    state: number;
+    isNative: BN | null;
+    delegatedAmount: BN;
+};

package/dist/types/test-utils/common.d.ts

@@ -0,0 +1,32 @@
+import { Connection, Keypair, PublicKey, Signer } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+import { LightWasm } from '@lightprotocol/hasher.rs';
+import { TestRpc } from './test-rpc';
+export declare const ALICE: Keypair;
+export declare const BOB: Keypair;
+export declare const CHARLIE: Keypair;
+export declare const DAVE: Keypair;
+export declare function newAccountWithLamports(rpc: Rpc, lamports?: number, counter?: number | undefined): Promise<Signer>;
+export declare function getConnection(): Connection;
+/**
+ * Returns a mock RPC instance for use in unit tests.
+ *
+ * @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 lightWasm               Wasm hasher instance.
+ * @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(endpoint?: string, proverEndpoint?: string, lightWasm?: LightWasm, merkleTreeAddress?: PublicKey, nullifierQueueAddress?: PublicKey, depth?: number, log?: boolean): Promise<TestRpc>;
+/**
+ * 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.
+ */
+export declare function getTestKeypair(counter?: number | undefined): Keypair;

package/dist/types/test-utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './merkle-tree';
+export * from './test-rpc';
+export * from './parse-event';
+export * from './parse-validity-proof';

package/dist/types/test-utils/merkle-tree.d.ts

@@ -0,0 +1,92 @@
+import { LightWasm } from '@lightprotocol/hasher.rs';
+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/types/test-utils/parse-event.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { ParsedTransactionWithMeta } from '@solana/web3.js';
+import { PublicTransactionEvent } from '../state';
+type Deserializer<T> = (data: Buffer, tx: ParsedTransactionWithMeta) => T;
+export declare const parseEvents: <T>(indexerEventsTransactions: (ParsedTransactionWithMeta | null)[], deserializeFn: Deserializer<T>) => NonNullable<T>[];
+export declare const parsePublicTransactionEventWithIdl: (data: Buffer) => PublicTransactionEvent | null;
+export {};

package/dist/types/test-utils/parse-validity-proof.d.ts

@@ -0,0 +1,20 @@
+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/types/test-utils/test-rpc.d.ts

@@ -0,0 +1,51 @@
+import { PublicKey } from '@solana/web3.js';
+import { LightWasm } from '@lightprotocol/hasher.rs';
+import { CompressedProofWithContext } from '../rpc-interface';
+import { BN254, PublicTransactionEvent } from '../state';
+import { 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;
+}
+/**
+ * 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 Rpc {
+    merkleTreeAddress: PublicKey;
+    nullifierQueueAddress: PublicKey;
+    lightWasm: LightWasm;
+    depth: number;
+    log: boolean;
+    /**
+     * Instantiate a mock RPC simulating the compression rpc interface.
+     *
+     * @param endpoint              endpoint to the solana cluster (use for
+     *                              localnet only)
+     * @param hasher                light wasm hasher instance
+     * @param testRpcConfig         Config for the mock rpc
+     * @param proverEndpoint        Optional endpoint to the prover server.
+     *                              defaults to endpoint
+     * @param connectionConfig      Optional connection config
+     */
+    constructor(endpoint: string, hasher: LightWasm, proverEndpoint: string, testRpcConfig?: TestRpcConfig, connectionConfig?: string);
+    /**
+     * @internal
+     * Returns newest first
+     * */
+    getParsedEvents(): Promise<PublicTransactionEvent[]>;
+    /** Retrieve validity proof for compressed accounts */
+    getValidityProof(compressedAccountHashes: BN254[]): Promise<CompressedProofWithContext>;
+}

package/dist/types/utils/airdrop.d.ts

@@ -0,0 +1,7 @@
+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/types/utils/conversion.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { Keypair } from '@solana/web3.js';
+export declare function byteArrayToKeypair(byteArray: number[]): Keypair;
+export declare const toArray: <T>(value: T | T[]) => T[];
+export declare const bufToDecStr: (buf: Buffer) => string;
+export declare function hashToBn254FieldSizeLe(bytes: Buffer): Promise<[Buffer, number] | null>;
+/** 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/types/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './conversion';
+export * from './pipe';
+export * from './send-and-confirm';
+export * from './sleep';
+export * from './airdrop';
+export * from './validation';

package/dist/types/utils/pipe.d.ts

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

package/dist/types/utils/send-and-confirm.d.ts

@@ -0,0 +1,18 @@
+import { VersionedTransaction, SignatureResult, RpcResponseAndContext, Signer, TransactionInstruction, ConfirmOptions, TransactionSignature } from '@solana/web3.js';
+import { Rpc } from '../rpc';
+/** Sends a versioned transaction and confirms it. */
+export declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, confirmOptions?: ConfirmOptions): Promise<TransactionSignature>;
+/** @internal */
+export declare function confirmTx(rpc: Rpc, txId: string, 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
+ */
+export declare function buildAndSignTx(instructions: TransactionInstruction[], payer: Signer, blockhash: string, additionalSigners?: Signer[]): VersionedTransaction;

package/dist/types/utils/sleep.d.ts

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

package/dist/types/utils/validation.d.ts

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

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

@@ -0,0 +1 @@
+export * from './use-wallet';

package/dist/types/wallet/interface.d.ts

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

package/dist/types/wallet/use-wallet.d.ts

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