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

package/dist/cjs/node/test-helpers/test-rpc/test-rpc.d.ts

@@ -1,8 +1,8 @@
-import { Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
+import { AccountInfo, Connection, ConnectionConfig, PublicKey } from '@solana/web3.js';
 import BN from 'bn.js';
 import { AddressWithTree, CompressedMintTokenHolders, CompressedTransaction, GetCompressedAccountsByOwnerConfig, PaginatedOptions, HashWithTree, LatestNonVotingSignatures, LatestNonVotingSignaturesPaginated, SignatureWithMetadata, WithContext, WithCursor } from '../../rpc-interface';
 import { ValidityProofWithContext, CompressionApiInterface, GetCompressedTokenAccountsByOwnerOrDelegateOptions, ParsedTokenAccount, TokenBalance } from '../../rpc-interface';
-import { BN254, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof } from '../../state';
+import { BN254, CompressedAccountWithMerkleContext, MerkleContext, MerkleContextWithMerkleProof } from '../../state';
 import { MerkleContextWithNewAddressProof } from '../../rpc';
 import { TreeInfo } from '../../state/types';
 export interface TestRpcConfig {
@@ -232,4 +232,8 @@ export declare class TestRpc extends Connection implements CompressionApiInterfa
      */
     getValidityProof(hashes?: BN254[], newAddresses?: BN254[]): Promise<ValidityProofWithContext>;
     getValidityProofV0(hashes?: HashWithTree[], newAddresses?: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    getCompressibleAccountInfo(address: PublicKey, programId: PublicKey, addressTreeInfo: TreeInfo, rpc: TestRpc): Promise<{
+        accountInfo: AccountInfo<Buffer>;
+        merkleContext?: MerkleContext;
+    } | null>;
 }

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

@@ -1,6 +1,19 @@
 import { PublicKey } from '@solana/web3.js';
+/**
+ * Derive an address for a compressed account from a seed and an address Merkle
+ * tree public key.
+ *
+ * @param seed                     32 bytes seed to derive the address from
+ * @param addressMerkleTreePubkey  Address Merkle tree public key as bytes.
+ * @param programIdBytes           Program ID bytes.
+ * @returns                        Derived address as bytes
+ */
+export declare function deriveAddressV2(seed: Uint8Array, addressMerkleTreePubkey: Uint8Array, programIdBytes: Uint8Array): Uint8Array;
+export declare function hashVWithBumpSeed(bytes: Uint8Array[]): Uint8Array;
 export declare function deriveAddressSeed(seeds: Uint8Array[], programId: PublicKey): Uint8Array;
 /**
+ * @deprecated Use {@link deriveAddressV2} instead, unless you're using v1.
+ *
  * Derive an address for a compressed account from a seed and an address Merkle
  * tree public key.
  *

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

@@ -22,6 +22,7 @@ export declare const toCamelCase: (object: any) => any;
  */
 export declare function hashToBn254FieldSizeBe(bytes: Buffer): [Buffer, number] | null;
 /**
+ * TODO: make consistent with latest rust. (use u8::max bumpseed)
  * Hash the provided `bytes` with Keccak256 and ensure that the result fits in
  * the BN254 prime field by truncating the resulting hash to 31 bytes.
  *

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

@@ -10,3 +10,4 @@ export * from './sleep';
 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;
+}