@lightprotocol/stateless.js 0.22.0 → 0.22.1-alpha.1

package/dist/es/browser/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/es/browser/programs/system/layout.d.ts

@@ -0,0 +1,77 @@
+import { Buffer } from 'buffer';
+import { PublicKey, AccountMeta } from '@solana/web3.js';
+import { Layout } from '@coral-xyz/borsh';
+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[];
+export declare const PublicTransactionEventLayout: Layout<PublicTransactionEvent>;
+export declare function encodePublicTransactionEvent(data: PublicTransactionEvent): Buffer;
+export declare function decodePublicTransactionEvent(buffer: Buffer): PublicTransactionEvent;
+export declare const AppendNullifyCreateAddressInputsMetaLayout: import("buffer-layout").Layout<unknown>;
+export declare const AppendLeavesInputLayout: import("buffer-layout").Layout<unknown>;
+export declare const InsertNullifierInputLayout: import("buffer-layout").Layout<unknown>;
+export declare const InsertAddressInputLayout: import("buffer-layout").Layout<unknown>;
+export declare const MerkleTreeSequenceNumberLayout: import("buffer-layout").Layout<unknown>;
+export declare function deserializeAppendNullifyCreateAddressInputsIndexer(buffer: Buffer): {
+    meta: unknown;
+    leaves: unknown[];
+    nullifiers: unknown[];
+    addresses: unknown[];
+    sequence_numbers: unknown[];
+    output_leaf_indices: number[];
+};
+export declare function convertToPublicTransactionEvent(decoded: any, remainingAccounts: PublicKey[], invokeData: InstructionDataInvoke): PublicTransactionEvent;

package/dist/es/browser/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/es/browser/programs/system/program.d.ts

@@ -0,0 +1,175 @@
+import BN from 'bn.js';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { CompressedAccountWithMerkleContext, ValidityProof, TreeInfo, CompressedAccountLegacy } from '../../state';
+import { NewAddressParams } from '../../utils';
+export declare const sumUpLamports: (accounts: CompressedAccountWithMerkleContext[]) => BN;
+/**
+ * Create compressed account system transaction params
+ */
+type CreateAccountWithSeedParams = {
+    /**
+     * The payer of the transaction.
+     */
+    payer: PublicKey;
+    /**
+     * 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: ValidityProof | null;
+    /**
+     * State tree pubkey. Defaults to a public state tree if unspecified.
+     */
+    outputStateTreeInfo?: TreeInfo;
+    /**
+     * Public key of the program to assign as the owner of the created account.
+     */
+    programId?: PublicKey;
+    /**
+     * Optional input accounts to transfer lamports from into the new compressed
+     * account.
+     */
+    inputCompressedAccounts?: CompressedAccountWithMerkleContext[];
+    /**
+     * Optional input state root indices of 'inputCompressedAccounts'. The
+     * expiry is tied to the 'recentValidityProof'.
+     */
+    inputStateRootIndices?: number[];
+    /**
+     * Optional lamports to transfer into the new compressed account.
+     */
+    lamports?: number | 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.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. Expires
+     * after n slots.
+     */
+    recentValidityProof: ValidityProof | null;
+};
+/**
+ * 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.
+     */
+    outputStateTreeInfo: TreeInfo;
+};
+/**
+ * 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.
+     */
+    recentInputStateRootIndices: number[];
+    /**
+     * The recent validity proof for state inclusion of the input state. It
+     * expires after n slots.
+     */
+    recentValidityProof: ValidityProof | null;
+};
+export declare class LightSystemProgram {
+    /**
+     * @internal
+     */
+    constructor();
+    /**
+     * The LightSystemProgram program ID.
+     */
+    static programId: PublicKey;
+    /**
+     * @internal
+     * Cwct1kQLwJm8Z3HetLu8m4SXkhD6FZ5fXbJQCxTxPnGY
+     *
+     */
+    static deriveCompressedSolPda(): PublicKey;
+    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[]): CompressedAccountLegacy[];
+    /**
+     * Creates instruction to create compressed account with PDA.
+     * Cannot write data.
+     */
+    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, }: TransferParams): Promise<TransactionInstruction>;
+    /**
+     * Creates a transaction instruction that transfers compressed lamports from
+     * one owner to another.
+     */
+    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, }: DecompressParams): Promise<TransactionInstruction>;
+}
+export {};

package/dist/es/browser/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];