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

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

@@ -1,6 +1,11 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { StateTreeInfo, TreeType } from '../state/types';
+import { TreeInfo, TreeType } from '../state/types';
 import { StateTreeLUTPair } from '../constants';
+/**
+ * @deprecated use {@link getTreeInfoByPubkey} instead
+ */
+export declare function getStateTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
+export declare function getTreeInfoByPubkey(treeInfos: TreeInfo[], treeOrQueue: PublicKey): TreeInfo;
 /**
  * @deprecated use {@link selectStateTreeInfo} instead.
  *
@@ -9,24 +14,26 @@ import { StateTreeLUTPair } from '../constants';
  * @param infos Set of state tree infos
  * @returns A random tree and queue
  */
-export declare function pickRandomTreeAndQueue(infos: StateTreeInfo[]): {
+export declare function pickRandomTreeAndQueue(infos: TreeInfo[]): {
     tree: PublicKey;
     queue: PublicKey;
 };
 /**
- * Get a pseudo-random active state tree info from the set of provided state
+ * Select a pseudo-random active state tree info from the set of provided state
  * tree infos.
  *
- * Using this mitigates write lock contention on state trees.
+ * Using this reduces write-lock contention on state trees.
  *
  * @param infos                 Set of state tree infos
- * @param treeType              The type of tree. Defaults to `TreeType.StateV1`
- * @param useMaxConcurrency     If true, return all infos. If false, return at
- *                              most {@link MAX_HOTSPOTS}. Defaults to `false`.
+ *
+ * @param treeType              Optional: Only use if you know what you are
+ *                              doing. The type of tree.
+ * @param useMaxConcurrency     Optional: Only use if you know what you are
+ *                              doing. If true, select from all infos.
  *
  * @returns A pseudo-randomly selected tree info
  */
-export declare function selectStateTreeInfo(infos: StateTreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): StateTreeInfo;
+export declare function selectStateTreeInfo(infos: TreeInfo[], treeType?: TreeType, useMaxConcurrency?: boolean): TreeInfo;
 /**
  * Get active state tree infos from LUTs.
  *
@@ -38,4 +45,4 @@ export declare function selectStateTreeInfo(infos: StateTreeInfo[], treeType?: T
 export declare function getAllStateTreeInfos({ connection, stateTreeLUTPairs, }: {
     connection: Connection;
     stateTreeLUTPairs: StateTreeLUTPair[];
-}): Promise<StateTreeInfo[]>;
+}): Promise<TreeInfo[]>;

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

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

package/dist/cjs/node/utils/packed-accounts.d.ts

@@ -0,0 +1,161 @@
+import { AccountMeta, PublicKey } from '@solana/web3.js';
+/**
+ * This file provides two variants of packed accounts for Light Protocol:
+ *
+ * 1. PackedAccounts - Matches CpiAccounts (11 system accounts)
+ *    - Includes: LightSystemProgram, Authority, RegisteredProgramPda, NoopProgram,
+ *      AccountCompressionAuthority, AccountCompressionProgram, InvokingProgram,
+ *      [Optional: SolPoolPda, DecompressionRecipient], SystemProgram, [Optional: CpiContext]
+ *
+ * 2. PackedAccountsSmall - Matches CpiAccountsSmall (9 system accounts max)
+ *    - Includes: LightSystemProgram, Authority, RegisteredProgramPda,
+ *      AccountCompressionAuthority, AccountCompressionProgram, SystemProgram,
+ *      [Optional: SolPoolPda, DecompressionRecipient, CpiContext]
+ *    - Excludes: NoopProgram and InvokingProgram for a more compact structure
+ */
+/**
+ * Create a PackedAccounts instance to pack the light protocol system accounts
+ * for your custom program instruction. Typically, you will append them to the
+ * end of your instruction's accounts / remainingAccounts.
+ *
+ * This matches the full CpiAccounts structure with 11 system accounts including
+ * NoopProgram and InvokingProgram. For a more compact version, use PackedAccountsSmall.
+ *
+ * @example
+ * ```ts
+ * const packedAccounts = PackedAccounts.newWithSystemAccounts(config);
+ *
+ * const instruction = new TransactionInstruction({
+ *     keys: [...yourInstructionAccounts, ...packedAccounts.toAccountMetas()],
+ *     programId: selfProgram,
+ *     data: data,
+ * });
+ * ```
+ */
+export declare class PackedAccounts {
+    private preAccounts;
+    private systemAccounts;
+    private nextIndex;
+    private map;
+    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccounts;
+    addPreAccountsSigner(pubkey: PublicKey): void;
+    addPreAccountsSignerMut(pubkey: PublicKey): void;
+    addPreAccountsMeta(accountMeta: AccountMeta): void;
+    addSystemAccounts(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;
+    };
+}
+/**
+ * Creates a PackedAccounts instance with system accounts for the specified
+ * program. This is a convenience wrapper around SystemAccountMetaConfig.new()
+ * and PackedAccounts.newWithSystemAccounts().
+ *
+ * @param programId - The program ID that will be using these system accounts
+ * @returns A new PackedAccounts instance with system accounts configured
+ *
+ * @example
+ * ```ts
+ * const packedAccounts = createPackedAccounts(myProgram.programId);
+ *
+ * const instruction = new TransactionInstruction({
+ *     keys: [...yourInstructionAccounts, ...packedAccounts.toAccountMetas().remainingAccounts],
+ *     programId: myProgram.programId,
+ *     data: instructionData,
+ * });
+ * ```
+ */
+export declare function createPackedAccounts(programId: PublicKey): PackedAccounts;
+/**
+ * Creates a PackedAccounts instance with system accounts and CPI context for the specified program.
+ * This is a convenience wrapper that includes CPI context configuration.
+ *
+ * @param programId - The program ID that will be using these system accounts
+ * @param cpiContext - The CPI context account public key
+ * @returns A new PackedAccounts instance with system accounts and CPI context configured
+ *
+ * @example
+ * ```ts
+ * const packedAccounts = createPackedAccountsWithCpiContext(
+ *     myProgram.programId,
+ *     cpiContextAccount
+ * );
+ * ```
+ */
+export declare function createPackedAccountsWithCpiContext(programId: PublicKey, cpiContext: PublicKey): PackedAccounts;
+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;
+}
+/**
+ * Get the light protocol system accounts for your custom program instruction.
+ * Use via `link PackedAccounts.addSystemAccounts(config)`.
+ */
+export declare function getLightSystemAccountMetas(config: SystemAccountMetaConfig): AccountMeta[];
+/**
+ * PackedAccountsSmall matches the CpiAccountsSmall structure with simplified account ordering.
+ * This is a more compact version that excludes NoopProgram and InvokingProgram.
+ */
+export declare class PackedAccountsSmall {
+    private preAccounts;
+    private systemAccounts;
+    private nextIndex;
+    private map;
+    static newWithSystemAccounts(config: SystemAccountMetaConfig): PackedAccountsSmall;
+    /**
+     * Returns the internal map of pubkey to [index, AccountMeta].
+     * For debugging purposes only.
+     */
+    getNamedMetas(): Map<string, [number, AccountMeta]>;
+    addPreAccountsSigner(pubkey: PublicKey): void;
+    addPreAccountsSignerMut(pubkey: PublicKey): void;
+    addPreAccountsMeta(accountMeta: AccountMeta): void;
+    addSystemAccounts(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;
+    };
+}
+/**
+ * Get the light protocol system accounts for the small variant.
+ * This matches CpiAccountsSmall ordering: removes NoopProgram and InvokingProgram.
+ */
+export declare function getLightSystemAccountMetasSmall(config: SystemAccountMetaConfig): AccountMeta[];
+/**
+ * Creates a PackedAccountsSmall instance with system accounts for the specified program.
+ * This uses the simplified account ordering that matches CpiAccountsSmall.
+ */
+export declare function createPackedAccountsSmall(programId: PublicKey): PackedAccountsSmall;
+/**
+ * Creates a PackedAccountsSmall instance with system accounts and CPI context.
+ */
+export declare function createPackedAccountsSmallWithCpiContext(programId: PublicKey, cpiContext: PublicKey): PackedAccountsSmall;
+export declare class SystemAccountPubkeys {
+    lightSystemProgram: PublicKey;
+    systemProgram: PublicKey;
+    accountCompressionProgram: PublicKey;
+    accountCompressionAuthority: PublicKey;
+    registeredProgramPda: PublicKey;
+    noopProgram: PublicKey;
+    solPoolPda: PublicKey;
+    private constructor();
+    static default(): SystemAccountPubkeys;
+}

package/dist/cjs/node/utils/send-and-confirm.d.ts

@@ -34,7 +34,7 @@ export declare function sendAndConfirmTx(rpc: Rpc, tx: VersionedTransaction, con
  * @param blockHashCtx      blockhash context for confirmation
  * @return SignatureResult
  */
-export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, blockHashCtx?: {
+export declare function confirmTx(rpc: Rpc, txId: string, confirmOptions?: ConfirmOptions, _blockHashCtx?: {
     blockhash: string;
     lastValidBlockHeight: number;
 }): Promise<RpcResponseAndContext<SignatureResult>>;

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

@@ -1,7 +1,7 @@
 import BN from 'bn.js';
-import { CompressedAccount, CompressedAccountWithMerkleContext } from '../state';
+import { CompressedAccountLegacy, CompressedAccountWithMerkleContext } from '../state';
 export declare const validateSufficientBalance: (balance: BN) => void;
-export declare const validateSameOwner: (compressedAccounts: CompressedAccount[] | CompressedAccountWithMerkleContext[]) => void;
+export declare const validateSameOwner: (compressedAccounts: CompressedAccountLegacy[] | CompressedAccountWithMerkleContext[]) => void;
 export declare const validateNumbersForProof: (hashesLength: number, newAddressesLength: number) => void;
 export declare const validateNumbersForInclusionProof: (hashesLength: number) => void;
 export declare const validateNumbersForNonInclusionProof: (newAddressesLength: number) => void;