@lightprotocol/stateless.js 0.20.9 → 0.22.0

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

@@ -1,11 +1,9 @@
 export * from './actions';
-export * from './instruction';
 export * from './programs';
 export * from './state';
+export * from './test-helpers';
 export * from './utils';
 export * from './constants';
 export * from './errors';
 export * from './rpc-interface';
 export * from './rpc';
-export * from './test-helpers';
-export { LightSystemProgram as LightSystemProgramIDL, IDL } from './idl';

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

@@ -1,2 +1 @@
 export * from './system';
-export * from './layout';

package/dist/cjs/{browser → node/programs/system}/idl.d.ts

@@ -698,7 +698,7 @@ export type LightSystemProgram = {
                         type: 'u8';
                     },
                     {
-                        name: 'nullifierQueuePubkeyIndex';
+                        name: 'queuePubkeyIndex';
                         type: 'u8';
                     },
                     {
@@ -706,30 +706,8 @@ export type LightSystemProgram = {
                         type: 'u32';
                     },
                     {
-                        name: 'queueIndex';
-                        type: {
-                            option: {
-                                defined: 'QueueIndex';
-                            };
-                        };
-                    }
-                ];
-            };
-        },
-        {
-            name: 'QueueIndex';
-            type: {
-                kind: 'struct';
-                fields: [
-                    {
-                        name: 'queueId';
-                        docs: ['Id of queue in queue account.'];
-                        type: 'u8';
-                    },
-                    {
-                        name: 'index';
-                        docs: ['Index of compressed account hash in queue.'];
-                        type: 'u16';
+                        name: 'proveByIndex';
+                        type: 'bool';
                     }
                 ];
             };
@@ -873,8 +851,8 @@ export type LightSystemProgram = {
         },
         {
             code: 6009;
-            name: 'DeCompressLamportsUndefinedForCompressSol';
-            msg: 'DeCompressLamportsUndefinedForCompressSol';
+            name: 'DecompressLamportsUndefinedForCompressSol';
+            msg: 'DecompressLamportsUndefinedForCompressSol';
         },
         {
             code: 6010;

package/dist/cjs/node/programs/system/index.d.ts

@@ -0,0 +1,5 @@
+export { LightSystemProgram as LightSystemProgramIDL, IDL } from './idl';
+export * from './layout';
+export * from './pack';
+export * from './program';
+export * from './select-compressed-accounts';

package/dist/cjs/node/programs/{layout.d.ts → system/layout.d.ts}

@@ -1,24 +1,60 @@
 import { Buffer } from 'buffer';
 import { PublicKey, AccountMeta } from '@solana/web3.js';
 import { Layout } from '@coral-xyz/borsh';
-import { InstructionDataInvoke, InstructionDataInvokeCpi, PublicTransactionEvent } from '../state';
+import { InstructionDataInvoke, InstructionDataInvokeCpi, PublicTransactionEvent } from '../../state';
 export declare const CompressedAccountLayout: import("buffer-layout").Layout<unknown>;
 export declare const MerkleContextLayout: import("buffer-layout").Layout<unknown>;
 export declare const NewAddressParamsLayout: import("buffer-layout").Layout<unknown>;
 export declare const InstructionDataInvokeLayout: Layout<InstructionDataInvoke>;
 export declare function encodeInstructionDataInvoke(data: InstructionDataInvoke): Buffer;
 export declare const InstructionDataInvokeCpiLayout: Layout<InstructionDataInvokeCpi>;
+export declare const CompressedProofLayout: import("buffer-layout").Layout<unknown>;
+export declare const CompressedCpiContextLayout: import("buffer-layout").Layout<unknown>;
+export declare const NewAddressParamsAssignedPackedLayout: import("buffer-layout").Layout<unknown>;
+export declare const PackedMerkleContextLayout: import("buffer-layout").Layout<unknown>;
+export declare const InAccountLayout: import("buffer-layout").Layout<unknown>;
+export declare const PackedReadOnlyAddressLayout: import("buffer-layout").Layout<unknown>;
+export declare const PackedReadOnlyCompressedAccountLayout: import("buffer-layout").Layout<unknown>;
+export declare const InstructionDataInvokeCpiWithReadOnlyLayout: import("buffer-layout").Layout<unknown>;
+export declare function decodeInstructionDataInvokeCpiWithReadOnly(buffer: Buffer): unknown;
 export declare function decodeInstructionDataInvoke(buffer: Buffer): InstructionDataInvoke;
 export declare function decodeInstructionDataInvokeCpi(buffer: Buffer): InstructionDataInvokeCpi;
 export type invokeAccountsLayoutParams = {
+    /**
+     * Fee payer.
+     */
     feePayer: PublicKey;
+    /**
+     * Authority.
+     */
     authority: PublicKey;
+    /**
+     * The registered program pda
+     */
     registeredProgramPda: PublicKey;
+    /**
+     * Noop program.
+     */
     noopProgram: PublicKey;
+    /**
+     * Account compression authority.
+     */
     accountCompressionAuthority: PublicKey;
+    /**
+     * Account compression program.
+     */
     accountCompressionProgram: PublicKey;
+    /**
+     * Solana pool pda. Some() if compression or decompression is done.
+     */
     solPoolPda: PublicKey | null;
+    /**
+     * Decompression recipient.
+     */
     decompressionRecipient: PublicKey | null;
+    /**
+     * Solana system program.
+     */
     systemProgram: PublicKey;
 };
 export declare const invokeAccountsLayout: (accounts: invokeAccountsLayoutParams) => AccountMeta[];

package/dist/cjs/node/programs/system/pack.d.ts

@@ -0,0 +1,74 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+import { AccountProofInput, CompressedAccountLegacy, NewAddressProofInput, OutputCompressedAccountWithPackedContext, PackedCompressedAccountWithMerkleContext, TreeInfo } from '../../state';
+import { CompressedAccountWithMerkleContextLegacy, PackedAddressTreeInfo, PackedStateTreeInfo } 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
+ * Pads output state trees with the 0th state tree of the input state.
+ *
+ * @param outputStateMerkleTrees                    Optional output state trees
+ *                                                  to be inserted into the
+ *                                                  output state. Defaults to
+ *                                                  the 0th state tree of the
+ *                                                  input state. Gets padded to
+ *                                                  the length of
+ *                                                  outputCompressedAccounts.
+ * @param numberOfOutputCompressedAccounts          The number of output
+ *                                                  compressed accounts.
+ *
+ * @returns Padded output state trees.
+ */
+export declare function padOutputStateMerkleTrees(outputStateMerkleTrees: PublicKey, numberOfOutputCompressedAccounts: number): PublicKey[];
+export declare function toAccountMetas(remainingAccounts: PublicKey[]): AccountMeta[];
+export interface PackedStateTreeInfos {
+    packedTreeInfos: PackedStateTreeInfo[];
+    outputTreeIndex: number;
+}
+export interface PackedTreeInfos {
+    stateTrees?: PackedStateTreeInfos;
+    addressTrees: PackedAddressTreeInfo[];
+}
+/**
+ * Packs TreeInfos. Replaces PublicKey with index pointer to remaining accounts.
+ *
+ * Only use for MUT, CLOSE, NEW_ADDRESSES. For INIT, pass
+ * {@link newAddressParamsPacked} and `outputStateTreeIndex` to your program
+ * instead.
+ *
+ *
+ * @param remainingAccounts                 Optional existing array of accounts
+ *                                          to append to.
+ * @param accountProofInputs                Account proof inputs.
+ * @param newAddressProofInputs             New address proof inputs.
+ *
+ * @returns Remaining accounts, packed state and address tree infos, state tree
+ * output index and address tree infos.
+ */
+export declare function packTreeInfos(remainingAccounts: PublicKey[], accountProofInputs: AccountProofInput[], newAddressProofInputs: NewAddressProofInput[]): PackedTreeInfos;
+/**
+ * Packs Compressed Accounts.
+ *
+ * Replaces PublicKey with index pointer to remaining accounts.
+ *
+ *
+ * @param inputCompressedAccounts           Ix input state to be consumed
+ * @param inputStateRootIndices             The recent state root indices of the
+ *                                          input state. The expiry is tied to
+ *                                          the proof.
+ * @param outputCompressedAccounts          Ix output state to be created
+ * @param outputStateTreeInfo               The output state tree info. Gets
+ *                                          padded to the length of
+ *                                          outputCompressedAccounts.
+ *
+ * @param remainingAccounts                 Optional existing array of accounts
+ *                                          to append to.
+ **/
+export declare function packCompressedAccounts(inputCompressedAccounts: CompressedAccountWithMerkleContextLegacy[], inputStateRootIndices: number[], outputCompressedAccounts: CompressedAccountLegacy[], outputStateTreeInfo?: TreeInfo, remainingAccounts?: PublicKey[]): {
+    packedInputCompressedAccounts: PackedCompressedAccountWithMerkleContext[];
+    packedOutputCompressedAccounts: OutputCompressedAccountWithPackedContext[];
+    remainingAccounts: PublicKey[];
+};

package/dist/cjs/node/programs/{system.d.ts → system/program.d.ts}

@@ -1,7 +1,7 @@
 import BN from 'bn.js';
 import { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { CompressedAccount, CompressedAccountWithMerkleContext, CompressedProof } from '../state';
-import { NewAddressParams } from '../utils';
+import { CompressedAccountWithMerkleContext, ValidityProof, TreeInfo, CompressedAccountLegacy } from '../../state';
+import { NewAddressParams } from '../../utils';
 export declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
 /**
  * Create compressed account system transaction params
@@ -12,21 +12,24 @@ type CreateAccountWithSeedParams = {
      */
     payer: PublicKey;
     /**
-     * Address params for the new compressed account
+     * Address params for the new compressed account.
      */
     newAddressParams: NewAddressParams;
+    /**
+     * Address of the new compressed account
+     */
     newAddress: number[];
     /**
      * Recent validity proof proving that there's no existing compressed account
      * registered with newAccountAddress
      */
-    recentValidityProof: CompressedProof;
+    recentValidityProof: ValidityProof | null;
     /**
      * State tree pubkey. Defaults to a public state tree if unspecified.
      */
-    outputStateTree?: PublicKey;
+    outputStateTreeInfo?: TreeInfo;
     /**
-     * Public key of the program to assign as the owner of the created account
+     * Public key of the program to assign as the owner of the created account.
      */
     programId?: PublicKey;
     /**
@@ -57,31 +60,23 @@ type TransferParams = {
      */
     inputCompressedAccounts: CompressedAccountWithMerkleContext[];
     /**
-     * Recipient address
+     * Recipient address.
      */
     toAddress: PublicKey;
     /**
-     * amount of lamports to transfer.
+     * 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.
+     * The recent validity proof for state inclusion of the input state. Expires
+     * after n slots.
      */
-    outputStateTrees?: PublicKey[] | PublicKey;
+    recentValidityProof: ValidityProof | null;
 };
 /**
  * Defines the parameters for the transfer method
@@ -100,10 +95,9 @@ type CompressParams = {
      */
     lamports: number | BN;
     /**
-     * The state tree that the tx output should be inserted into. Defaults to a
-     * public state tree if unspecified.
+     * The state tree that the tx output should be inserted into.
      */
-    outputStateTree?: PublicKey;
+    outputStateTreeInfo: TreeInfo;
 };
 /**
  * Defines the parameters for the transfer method
@@ -128,21 +122,13 @@ type DecompressParams = {
     /**
      * 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;
+    recentValidityProof: ValidityProof | null;
 };
 export declare class LightSystemProgram {
     /**
@@ -150,7 +136,7 @@ export declare class LightSystemProgram {
      */
     constructor();
     /**
-     * Public key that identifies the CompressedPda program
+     * The LightSystemProgram program ID.
      */
     static programId: PublicKey;
     /**
@@ -159,41 +145,31 @@ export declare class LightSystemProgram {
      *
      */
     static deriveCompressedSolPda(): PublicKey;
-    static createTransferOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], toAddress: PublicKey, lamports: number | BN): CompressedAccount[];
-    static createDecompressOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], lamports: number | BN): CompressedAccount[];
+    static createTransferOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], toAddress: PublicKey, lamports: number | BN): CompressedAccountLegacy[];
+    static createDecompressOutputState(inputCompressedAccounts: CompressedAccountWithMerkleContext[], lamports: number | BN): CompressedAccountLegacy[];
     /**
      * No data by default
      */
-    static createNewAddressOutputState(address: number[], owner: PublicKey, lamports?: BN | number, inputCompressedAccounts?: CompressedAccountWithMerkleContext[]): CompressedAccount[];
+    static createNewAddressOutputState(address: number[], owner: PublicKey, lamports?: BN | number, inputCompressedAccounts?: CompressedAccountWithMerkleContext[]): CompressedAccountLegacy[];
     /**
      * Creates instruction to create compressed account with PDA.
      * Cannot write data.
-     *
-     * TODO: support transfer of lamports to the new account.
      */
-    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTree, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
+    static createAccount({ payer, newAddressParams, newAddress, recentValidityProof, outputStateTreeInfo, inputCompressedAccounts, inputStateRootIndices, lamports, }: CreateAccountWithSeedParams): Promise<TransactionInstruction>;
     /**
      * Creates a transaction instruction that transfers compressed lamports from
      * one owner to another.
      */
-    static transfer({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, outputStateTrees, }: TransferParams): Promise<TransactionInstruction>;
+    static transfer({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: TransferParams): Promise<TransactionInstruction>;
     /**
      * Creates a transaction instruction that transfers compressed lamports from
      * one owner to another.
      */
-    static compress({ payer, toAddress, lamports, outputStateTree, }: CompressParams): Promise<TransactionInstruction>;
+    static compress({ payer, toAddress, lamports, outputStateTreeInfo, }: CompressParams): Promise<TransactionInstruction>;
     /**
      * Creates a transaction instruction that transfers compressed lamports from
      * one owner to another.
      */
-    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, outputStateTree, }: DecompressParams): Promise<TransactionInstruction>;
+    static decompress({ payer, inputCompressedAccounts, toAddress, lamports, recentInputStateRootIndices, recentValidityProof, }: DecompressParams): Promise<TransactionInstruction>;
 }
-/**
- * Selects the minimal number of compressed SOL accounts for a transfer.
- *
- * 1. Sorts the accounts by amount in descending order
- * 2. Accumulates the amount until it is greater than or equal to the transfer
- *    amount
- */
-export declare function selectMinCompressedSolAccountsForTransfer(accounts: CompressedAccountWithMerkleContext[], transferLamports: BN | number): [selectedAccounts: CompressedAccountWithMerkleContext[], total: BN];
 export {};

package/dist/cjs/node/programs/system/select-compressed-accounts.d.ts

@@ -0,0 +1,10 @@
+import BN from 'bn.js';
+import { CompressedAccountWithMerkleContext } from '../../state';
+/**
+ * Selects the minimal number of compressed SOL accounts for a transfer.
+ *
+ * 1. Sorts the accounts by amount in descending order
+ * 2. Accumulates the amount until it is greater than or equal to the transfer
+ *    amount
+ */
+export declare function selectMinCompressedSolAccountsForTransfer(accounts: CompressedAccountWithMerkleContext[], transferLamports: BN | number): [selectedAccounts: CompressedAccountWithMerkleContext[], total: BN];