@bitgo/wasm-solana 1.4.1 → 1.4.2

package/dist/cjs/js/wasm/wasm_solana.d.ts

@@ -0,0 +1,1030 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class AeCiphertext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class AeKey {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  decrypt(ciphertext: AeCiphertext): bigint | undefined;
+  /**
+   * Encrypts an amount under the authenticated encryption key.
+   */
+  encrypt(amount: bigint): AeCiphertext;
+  /**
+   * Generates a random authenticated encryption key.
+   *
+   * This function is randomized. It internally samples a scalar element using `OsRng`.
+   */
+  static newRand(): AeKey;
+}
+
+export class BatchedGroupedCiphertext2HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class BatchedGroupedCiphertext2HandlesValidityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): BatchedGroupedCiphertext2HandlesValidityProofContext;
+  toBytes(): Uint8Array;
+  first_pubkey: PodElGamalPubkey;
+  second_pubkey: PodElGamalPubkey;
+  grouped_ciphertext_lo: PodGroupedElGamalCiphertext2Handles;
+  grouped_ciphertext_hi: PodGroupedElGamalCiphertext2Handles;
+}
+
+export class BatchedGroupedCiphertext2HandlesValidityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): BatchedGroupedCiphertext2HandlesValidityProofData;
+  static new(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, grouped_ciphertext_lo: GroupedElGamalCiphertext2Handles, grouped_ciphertext_hi: GroupedElGamalCiphertext2Handles, amount_lo: bigint, amount_hi: bigint, opening_lo: PedersenOpening, opening_hi: PedersenOpening): BatchedGroupedCiphertext2HandlesValidityProofData;
+  toBytes(): Uint8Array;
+  context: BatchedGroupedCiphertext2HandlesValidityProofContext;
+  proof: PodBatchedGroupedCiphertext2HandlesValidityProof;
+}
+
+export class BatchedGroupedCiphertext3HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class BatchedGroupedCiphertext3HandlesValidityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): BatchedGroupedCiphertext3HandlesValidityProofContext;
+  toBytes(): Uint8Array;
+  first_pubkey: PodElGamalPubkey;
+  second_pubkey: PodElGamalPubkey;
+  third_pubkey: PodElGamalPubkey;
+  grouped_ciphertext_lo: PodGroupedElGamalCiphertext3Handles;
+  grouped_ciphertext_hi: PodGroupedElGamalCiphertext3Handles;
+}
+
+export class BatchedGroupedCiphertext3HandlesValidityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): BatchedGroupedCiphertext3HandlesValidityProofData;
+  static new(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, third_pubkey: ElGamalPubkey, grouped_ciphertext_lo: GroupedElGamalCiphertext3Handles, grouped_ciphertext_hi: GroupedElGamalCiphertext3Handles, amount_lo: bigint, amount_hi: bigint, opening_lo: PedersenOpening, opening_hi: PedersenOpening): BatchedGroupedCiphertext3HandlesValidityProofData;
+  toBytes(): Uint8Array;
+  context: BatchedGroupedCiphertext3HandlesValidityProofContext;
+  proof: PodBatchedGroupedCiphertext3HandlesValidityProof;
+}
+
+export class BuilderNamespace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Build a Solana transaction from an intent structure.
+   *
+   * Takes a TransactionIntent JSON object and returns serialized transaction bytes.
+   *
+   * # Intent Structure
+   *
+   * ```json
+   * {
+   *   "feePayer": "DgT9qyYwYKBRDyDw3EfR12LHQCQjtNrKu2qMsXHuosmB",
+   *   "nonce": {
+   *     "type": "blockhash",
+   *     "value": "GWaQEymC3Z9SHM2gkh8u12xL1zJPMHPCSVR3pSDpEXE4"
+   *   },
+   *   "instructions": [
+   *     { "type": "transfer", "from": "...", "to": "...", "lamports": "1000000" },
+   *     { "type": "memo", "message": "BitGo tx" }
+   *   ]
+   * }
+   * ```
+   *
+   * # Instruction Types
+   *
+   * - `transfer`: SOL transfer (from, to, lamports)
+   * - `createAccount`: Create new account (from, newAccount, lamports, space, owner)
+   * - `nonceAdvance`: Advance durable nonce (nonce, authority)
+   * - `nonceInitialize`: Initialize nonce account (nonce, authority)
+   * - `allocate`: Allocate space (account, space)
+   * - `assign`: Assign to program (account, owner)
+   * - `memo`: Add memo (message)
+   * - `computeBudget`: Set compute units (unitLimit, unitPrice)
+   *
+   * # Returns
+   *
+   * A `Transaction` object that can be inspected, signed, and serialized.
+   * The transaction will have empty signature placeholders that can be
+   * filled in later by signing via `addSignature()`.
+   *
+   * @param intent - The transaction intent as a JSON object
+   * @returns Transaction object
+   */
+  static build_transaction(intent: any): WasmTransaction;
+  /**
+   * Build a versioned transaction directly from raw MessageV0 data.
+   *
+   * This function is used for the `fromVersionedTransactionData()` path where we already
+   * have pre-compiled versioned data (indexes + ALT refs). No instruction compilation
+   * is needed - we just serialize the raw structure to bytes.
+   *
+   * # Data Structure
+   *
+   * ```json
+   * {
+   *   "staticAccountKeys": ["pubkey1", "pubkey2", ...],
+   *   "addressLookupTables": [
+   *     { "accountKey": "altPubkey", "writableIndexes": [0, 1], "readonlyIndexes": [2] }
+   *   ],
+   *   "versionedInstructions": [
+   *     { "programIdIndex": 0, "accountKeyIndexes": [1, 2], "data": "base58EncodedData" }
+   *   ],
+   *   "messageHeader": {
+   *     "numRequiredSignatures": 1,
+   *     "numReadonlySignedAccounts": 0,
+   *     "numReadonlyUnsignedAccounts": 3
+   *   },
+   *   "recentBlockhash": "blockhash"
+   * }
+   * ```
+   *
+   * @param data - Raw versioned transaction data as a JSON object
+   * @returns VersionedTransaction object
+   */
+  static build_from_versioned_data(data: any): WasmVersionedTransaction;
+}
+
+export class CiphertextCiphertextEqualityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class CiphertextCiphertextEqualityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): CiphertextCiphertextEqualityProofContext;
+  toBytes(): Uint8Array;
+  first_pubkey: PodElGamalPubkey;
+  second_pubkey: PodElGamalPubkey;
+  first_ciphertext: PodElGamalCiphertext;
+  second_ciphertext: PodElGamalCiphertext;
+}
+
+export class CiphertextCiphertextEqualityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): CiphertextCiphertextEqualityProofData;
+  static new(first_keypair: ElGamalKeypair, second_pubkey: ElGamalPubkey, first_ciphertext: ElGamalCiphertext, second_ciphertext: ElGamalCiphertext, second_opening: PedersenOpening, amount: bigint): CiphertextCiphertextEqualityProofData;
+  toBytes(): Uint8Array;
+  context: CiphertextCiphertextEqualityProofContext;
+  proof: PodCiphertextCiphertextEqualityProof;
+}
+
+export class CiphertextCommitmentEqualityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class CiphertextCommitmentEqualityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): CiphertextCommitmentEqualityProofContext;
+  toBytes(): Uint8Array;
+  /**
+   * The ElGamal pubkey
+   */
+  pubkey: PodElGamalPubkey;
+  /**
+   * The ciphertext encrypted under the ElGamal pubkey
+   */
+  ciphertext: PodElGamalCiphertext;
+  /**
+   * The Pedersen commitment
+   */
+  commitment: PodPedersenCommitment;
+}
+
+export class CiphertextCommitmentEqualityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): CiphertextCommitmentEqualityProofData;
+  static new(keypair: ElGamalKeypair, ciphertext: ElGamalCiphertext, commitment: PedersenCommitment, opening: PedersenOpening, amount: bigint): CiphertextCommitmentEqualityProofData;
+  toBytes(): Uint8Array;
+  context: CiphertextCommitmentEqualityProofContext;
+  proof: PodCiphertextCommitmentEqualityProof;
+}
+
+export class DecryptHandle {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class ElGamalCiphertext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  commitment: PedersenCommitment;
+  handle: DecryptHandle;
+}
+
+export class ElGamalKeypair {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  pubkeyOwned(): ElGamalPubkey;
+  /**
+   * Generates the public and secret keys for ElGamal encryption.
+   *
+   * This function is randomized. It internally samples a scalar element using `OsRng`.
+   */
+  static newRand(): ElGamalKeypair;
+}
+
+export class ElGamalPubkey {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  encryptU64(amount: bigint): ElGamalCiphertext;
+  encryptWithU64(amount: bigint, opening: PedersenOpening): ElGamalCiphertext;
+}
+
+export class GroupedCiphertext2HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class GroupedCiphertext2HandlesValidityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): GroupedCiphertext2HandlesValidityProofContext;
+  toBytes(): Uint8Array;
+  first_pubkey: PodElGamalPubkey;
+  second_pubkey: PodElGamalPubkey;
+  grouped_ciphertext: PodGroupedElGamalCiphertext2Handles;
+}
+
+export class GroupedCiphertext2HandlesValidityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): GroupedCiphertext2HandlesValidityProofData;
+  static new(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, grouped_ciphertext: GroupedElGamalCiphertext2Handles, amount: bigint, opening: PedersenOpening): GroupedCiphertext2HandlesValidityProofData;
+  toBytes(): Uint8Array;
+  context: GroupedCiphertext2HandlesValidityProofContext;
+  proof: PodGroupedCiphertext2HandlesValidityProof;
+}
+
+export class GroupedCiphertext3HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class GroupedCiphertext3HandlesValidityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): GroupedCiphertext3HandlesValidityProofContext;
+  toBytes(): Uint8Array;
+  first_pubkey: PodElGamalPubkey;
+  second_pubkey: PodElGamalPubkey;
+  third_pubkey: PodElGamalPubkey;
+  grouped_ciphertext: PodGroupedElGamalCiphertext3Handles;
+}
+
+export class GroupedCiphertext3HandlesValidityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): GroupedCiphertext3HandlesValidityProofData;
+  static new(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, third_pubkey: ElGamalPubkey, grouped_ciphertext: GroupedElGamalCiphertext3Handles, amount: bigint, opening: PedersenOpening): GroupedCiphertext3HandlesValidityProofData;
+  toBytes(): Uint8Array;
+  context: GroupedCiphertext3HandlesValidityProofContext;
+  proof: PodGroupedCiphertext3HandlesValidityProof;
+}
+
+export class GroupedElGamalCiphertext2Handles {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static encryptU64(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, amount: bigint): GroupedElGamalCiphertext2Handles;
+  static encryptionWithU64(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, amount: bigint, opening: PedersenOpening): GroupedElGamalCiphertext2Handles;
+}
+
+export class GroupedElGamalCiphertext3Handles {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static encryptU64(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, third_pubkey: ElGamalPubkey, amount: bigint): GroupedElGamalCiphertext3Handles;
+  static encryptionWithU64(first_pubkey: ElGamalPubkey, second_pubkey: ElGamalPubkey, third_pubkey: ElGamalPubkey, amount: bigint, opening: PedersenOpening): GroupedElGamalCiphertext3Handles;
+}
+
+export class Hash {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new Hash object
+   *
+   * * `value` - optional hash as a base58 encoded string, `Uint8Array`, `[number]`
+   */
+  constructor(value: any);
+  /**
+   * Checks if two `Hash`s are equal
+   */
+  equals(other: Hash): boolean;
+  /**
+   * Return the `Uint8Array` representation of the hash
+   */
+  toBytes(): Uint8Array;
+  /**
+   * Return the base58 string representation of the hash
+   */
+  toString(): string;
+}
+
+export class Instruction {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class Instructions {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  push(instruction: Instruction): void;
+}
+
+export class Keypair {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new `Keypair `
+   */
+  constructor();
+  /**
+   * Convert a `Keypair` to a `Uint8Array`
+   */
+  toBytes(): Uint8Array;
+  /**
+   * Recover a `Keypair` from a `Uint8Array`
+   */
+  static fromBytes(bytes: Uint8Array): Keypair;
+  /**
+   * Return the `Pubkey` for this `Keypair`
+   */
+  pubkey(): Pubkey;
+}
+
+export class Message {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The id of a recent ledger entry.
+   */
+  recent_blockhash: Hash;
+}
+
+export class ParserNamespace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Parse a serialized Solana transaction into structured data.
+   *
+   * Takes raw transaction bytes and returns a JavaScript object with:
+   * - `feePayer`: The fee payer address (base58)
+   * - `numSignatures`: Number of required signatures
+   * - `nonce`: The blockhash/nonce value (base58)
+   * - `durableNonce`: Optional durable nonce info (if tx uses nonce)
+   * - `instructionsData`: Array of decoded instructions with semantic types
+   * - `accountKeys`: Array of all account addresses (base58)
+   *
+   * Each instruction in `instructionsData` has a `type` field identifying the
+   * instruction type (e.g., "Transfer", "StakingActivate", "TokenTransfer").
+   *
+   * Amount fields (amount, fee, lamports, poolTokens) are returned as BigInt.
+   *
+   * @param bytes - The raw transaction bytes (wire format)
+   * @returns A ParsedTransaction object
+   */
+  static parse_transaction(bytes: Uint8Array): any;
+}
+
+export class Pedersen {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static withU64(amount: bigint, opening: PedersenOpening): PedersenCommitment;
+}
+
+export class PedersenCommitment {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PedersenOpening {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static newRand(): PedersenOpening;
+}
+
+export class PercentageWithCapProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PercentageWithCapProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): PercentageWithCapProofContext;
+  toBytes(): Uint8Array;
+  /**
+   * The Pedersen commitment to the percentage amount.
+   */
+  percentage_commitment: PodPedersenCommitment;
+  /**
+   * The Pedersen commitment to the delta amount.
+   */
+  delta_commitment: PodPedersenCommitment;
+  /**
+   * The Pedersen commitment to the claimed amount.
+   */
+  claimed_commitment: PodPedersenCommitment;
+  /**
+   * The maximum cap bound.
+   */
+  max_value: PodU64;
+}
+
+export class PercentageWithCapProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): PercentageWithCapProofData;
+  static new(percentage_commitment: PedersenCommitment, percentage_opening: PedersenOpening, percentage_amount: bigint, delta_commitment: PedersenCommitment, delta_opening: PedersenOpening, delta_amount: bigint, claimed_commitment: PedersenCommitment, claimed_opening: PedersenOpening, max_value: bigint): PercentageWithCapProofData;
+  toBytes(): Uint8Array;
+  context: PercentageWithCapProofContext;
+  proof: PodPercentageWithCapProof;
+}
+
+export class PodAeCiphertext {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(value: any);
+  decode(): AeCiphertext;
+  static encode(decoded: AeCiphertext): PodAeCiphertext;
+  equals(other: PodAeCiphertext): boolean;
+  static zeroed(): PodAeCiphertext;
+  toBytes(): Uint8Array;
+  toString(): string;
+}
+
+export class PodBatchedGroupedCiphertext2HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodBatchedGroupedCiphertext3HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodCiphertextCiphertextEqualityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodCiphertextCommitmentEqualityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodElGamalCiphertext {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(value: any);
+  decode(): ElGamalCiphertext;
+  static encode(decoded: ElGamalCiphertext): PodElGamalCiphertext;
+  equals(other: PodElGamalCiphertext): boolean;
+  static zeroed(): PodElGamalCiphertext;
+  toBytes(): Uint8Array;
+  toString(): string;
+}
+
+export class PodElGamalPubkey {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(value: any);
+  decode(): ElGamalPubkey;
+  static encode(decoded: ElGamalPubkey): PodElGamalPubkey;
+  equals(other: PodElGamalPubkey): boolean;
+  static zeroed(): PodElGamalPubkey;
+  toBytes(): Uint8Array;
+  toString(): string;
+}
+
+export class PodGroupedCiphertext2HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodGroupedCiphertext3HandlesValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodGroupedElGamalCiphertext2Handles {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodGroupedElGamalCiphertext3Handles {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodPedersenCommitment {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodPercentageWithCapProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodPubkeyValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodU64 {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PodZeroCiphertextProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class Pubkey {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new Pubkey object
+   *
+   * * `value` - optional public key as a base58 encoded string, `Uint8Array`, `[number]`
+   */
+  constructor(value: any);
+  /**
+   * Derive a Pubkey from another Pubkey, string seed, and a program id
+   */
+  static createWithSeed(base: Pubkey, seed: string, owner: Pubkey): Pubkey;
+  /**
+   * Find a valid program address
+   *
+   * Returns:
+   * * `[PubKey, number]` - the program address and bump seed
+   */
+  static findProgramAddress(seeds: any[], program_id: Pubkey): any;
+  /**
+   * Derive a program address from seeds and a program id
+   */
+  static createProgramAddress(seeds: any[], program_id: Pubkey): Pubkey;
+  /**
+   * Checks if two `Pubkey`s are equal
+   */
+  equals(other: Pubkey): boolean;
+  /**
+   * Return the `Uint8Array` representation of the public key
+   */
+  toBytes(): Uint8Array;
+  /**
+   * Return the base58 string representation of the public key
+   */
+  toString(): string;
+  /**
+   * Check if a `Pubkey` is on the ed25519 curve.
+   */
+  isOnCurve(): boolean;
+}
+
+export class PubkeyValidityProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class PubkeyValidityProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): PubkeyValidityProofContext;
+  toBytes(): Uint8Array;
+  /**
+   * The public key to be proved
+   */
+  pubkey: PodElGamalPubkey;
+}
+
+export class PubkeyValidityProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): PubkeyValidityProofData;
+  static new(keypair: ElGamalKeypair): PubkeyValidityProofData;
+  toBytes(): Uint8Array;
+  /**
+   * The context data for the public key validity proof
+   */
+  context: PubkeyValidityProofContext;
+  /**
+   * Proof that the public key is well-formed
+   */
+  proof: PodPubkeyValidityProof;
+}
+
+export class WasmKeypair {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a keypair from a 32-byte secret key.
+   */
+  static from_secret_key(secret_key: Uint8Array): WasmKeypair;
+  /**
+   * Create a keypair from a 64-byte Solana secret key (secret + public concatenated).
+   */
+  static from_solana_secret_key(secret_key: Uint8Array): WasmKeypair;
+  /**
+   * Get the address as a base58 string.
+   */
+  address(): string;
+  /**
+   * Get the public key as a base58 string.
+   */
+  to_base58(): string;
+  /**
+   * Get the public key as a 32-byte Uint8Array.
+   */
+  readonly public_key: Uint8Array;
+  /**
+   * Get the secret key as a 32-byte Uint8Array.
+   */
+  readonly secret_key: Uint8Array;
+}
+
+export class WasmPubkey {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a Pubkey from raw bytes (32 bytes).
+   */
+  static from_bytes(bytes: Uint8Array): WasmPubkey;
+  /**
+   * Create a Pubkey from a base58 string.
+   */
+  static from_base58(address: string): WasmPubkey;
+  /**
+   * Check if this public key is on the Ed25519 curve.
+   */
+  is_on_curve(): boolean;
+  /**
+   * Check if two pubkeys are equal.
+   */
+  equals(other: WasmPubkey): boolean;
+  /**
+   * Get as raw bytes (32 bytes).
+   */
+  to_bytes(): Uint8Array;
+  /**
+   * Convert to base58 string (the standard Solana address format).
+   */
+  to_base58(): string;
+}
+
+export class WasmTransaction {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Deserialize a transaction from raw bytes.
+   */
+  static from_bytes(bytes: Uint8Array): WasmTransaction;
+  /**
+   * Get all signatures as an array of byte arrays.
+   *
+   * Each signature is returned as a Uint8Array.
+   */
+  signatures(): Array<any>;
+  /**
+   * Get all account keys as an array of base58 strings.
+   */
+  account_keys(): Array<any>;
+  /**
+   * Get all instructions as an array.
+   *
+   * Each instruction is a JS object with programId, accounts, and data.
+   */
+  instructions(): Array<any>;
+  /**
+   * Check if a public key is a required signer for this transaction.
+   *
+   * @param pubkey - The public key as a base58 string
+   * @returns The signer index if the pubkey is a signer, null otherwise
+   */
+  signer_index(pubkey: string): number | undefined;
+  /**
+   * Add a signature for a given public key.
+   *
+   * The pubkey must be one of the required signers in the transaction.
+   * The signature must be exactly 64 bytes (Ed25519 signature).
+   *
+   * @param pubkey - The public key as a base58 string
+   * @param signature - The 64-byte signature
+   */
+  add_signature(pubkey: string, signature: Uint8Array): void;
+  /**
+   * Get the signable message payload (what gets signed).
+   *
+   * This is the serialized message that signers sign.
+   */
+  signable_payload(): Uint8Array;
+  /**
+   * Serialize the transaction to bytes.
+   */
+  to_bytes(): Uint8Array;
+  /**
+   * Get the number of signatures in the transaction.
+   */
+  readonly num_signatures: number;
+  /**
+   * Get the number of instructions in the transaction.
+   */
+  readonly num_instructions: number;
+  /**
+   * Get the recent blockhash as a base58 string.
+   */
+  readonly recent_blockhash: string;
+  /**
+   * Get the fee payer address as a base58 string.
+   *
+   * Returns `null` if there are no account keys (shouldn't happen for valid transactions).
+   */
+  readonly fee_payer: string | undefined;
+}
+
+export class WasmVersionedTransaction {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Deserialize a transaction from raw bytes.
+   *
+   * Automatically handles both legacy and versioned formats.
+   */
+  static from_bytes(bytes: Uint8Array): WasmVersionedTransaction;
+  /**
+   * Get all signatures as an array of byte arrays.
+   */
+  signatures(): Array<any>;
+  /**
+   * Get all instructions as an array.
+   *
+   * Note: For versioned transactions with ALTs, account indices may
+   * reference accounts beyond static_account_keys. Use address_lookup_tables()
+   * to resolve additional accounts.
+   */
+  instructions(): Array<any>;
+  /**
+   * Check if a public key is a required signer.
+   *
+   * @returns The signer index if the pubkey is a signer, null otherwise
+   */
+  signer_index(pubkey: string): number | undefined;
+  /**
+   * Add a signature for a given public key.
+   *
+   * @param pubkey - The public key as a base58 string
+   * @param signature - The 64-byte signature
+   */
+  add_signature(pubkey: string, signature: Uint8Array): void;
+  /**
+   * Get the signable message payload.
+   */
+  signable_payload(): Uint8Array;
+  /**
+   * Get static account keys (accounts stored directly in the message).
+   *
+   * For versioned transactions, additional accounts may be referenced
+   * via Address Lookup Tables.
+   */
+  static_account_keys(): Array<any>;
+  /**
+   * Get Address Lookup Table data.
+   *
+   * Returns an array of ALT objects, each containing:
+   * - accountKey: The lookup table account address
+   * - writableIndexes: Indices of writable accounts in the table
+   * - readonlyIndexes: Indices of readonly accounts in the table
+   *
+   * For legacy transactions, returns an empty array.
+   */
+  address_lookup_tables(): Array<any>;
+  /**
+   * Serialize the transaction to bytes.
+   */
+  to_bytes(): Uint8Array;
+  /**
+   * Check if this is a versioned transaction (MessageV0).
+   *
+   * @returns true for MessageV0, false for legacy
+   */
+  readonly is_versioned: boolean;
+  /**
+   * Get the number of signatures.
+   */
+  readonly num_signatures: number;
+  /**
+   * Get the number of instructions.
+   */
+  readonly num_instructions: number;
+  /**
+   * Get the recent blockhash as a base58 string.
+   */
+  readonly recent_blockhash: string;
+  /**
+   * Get the fee payer address as a base58 string.
+   */
+  readonly fee_payer: string | undefined;
+}
+
+export class ZeroCiphertextProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+
+export class ZeroCiphertextProofContext {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): ZeroCiphertextProofContext;
+  toBytes(): Uint8Array;
+  /**
+   * The ElGamal pubkey associated with the ElGamal ciphertext
+   */
+  pubkey: PodElGamalPubkey;
+  /**
+   * The ElGamal ciphertext that encrypts zero
+   */
+  ciphertext: PodElGamalCiphertext;
+}
+
+export class ZeroCiphertextProofData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromBytes(bytes: Uint8Array): ZeroCiphertextProofData;
+  static new(keypair: ElGamalKeypair, ciphertext: ElGamalCiphertext): ZeroCiphertextProofData;
+  toBytes(): Uint8Array;
+  /**
+   * The context data for the zero-ciphertext proof
+   */
+  context: ZeroCiphertextProofContext;
+  /**
+   * Proof that the ciphertext is zero
+   */
+  proof: PodZeroCiphertextProof;
+}
+
+/**
+ * Associated Token Account Program ID
+ */
+export function ata_program_id(): string;
+
+/**
+ * Compute Budget Program ID
+ */
+export function compute_budget_program_id(): string;
+
+/**
+ * Derive the Stake Pool withdraw authority PDA.
+ *
+ * This allows JavaScript code to compute the withdraw authority without needing @solana/spl-stake-pool.
+ * The withdraw authority is a PDA derived from seeds: ["withdraw", stake_pool_address]
+ *
+ * @param stake_pool_address - Stake pool address (base58)
+ * @returns The derived withdraw authority address (base58)
+ */
+export function find_withdraw_authority_program_address(stake_pool_address: string): string;
+
+/**
+ * Derive the Associated Token Account address for a given wallet and mint.
+ *
+ * This allows JavaScript code to compute ATA addresses without needing @solana/web3.js.
+ * The ATA is a PDA derived from seeds: [wallet_address, token_program_id, mint_address]
+ *
+ * @param wallet_address - Owner wallet address (base58)
+ * @param mint_address - Token mint address (base58)
+ * @param token_program_id - Token program ID (base58), use TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID
+ * @returns The derived ATA address (base58)
+ */
+export function get_associated_token_address(wallet_address: string, mint_address: string, token_program_id: string): string;
+
+/**
+ * Detect if transaction bytes represent a versioned transaction.
+ *
+ * @param bytes - Raw transaction bytes
+ * @returns true if versioned (MessageV0), false if legacy
+ */
+export function is_versioned_transaction(bytes: Uint8Array): boolean;
+
+/**
+ * Memo Program ID
+ */
+export function memo_program_id(): string;
+
+/**
+ * Nonce account space in bytes (80)
+ */
+export function nonce_account_space(): bigint;
+
+/**
+ * Initialize Javascript logging and panic handler
+ */
+export function solana_program_init(): void;
+
+/**
+ * Stake account space in bytes (200)
+ */
+export function stake_account_space(): bigint;
+
+/**
+ * Stake Pool Program ID (Jito)
+ */
+export function stake_pool_program_id(): string;
+
+/**
+ * Stake Program ID
+ */
+export function stake_program_id(): string;
+
+/**
+ * System Program ID
+ */
+export function system_program_id(): string;
+
+/**
+ * Sysvar Recent Blockhashes address
+ * Reference: https://github.com/solana-labs/solana/blob/v1.18.26/sdk/program/src/sysvar/recent_blockhashes.rs
+ */
+export function sysvar_recent_blockhashes(): string;
+
+/**
+ * Token 2022 Program ID
+ */
+export function token_2022_program_id(): string;
+
+/**
+ * Token Program ID (SPL Token)
+ */
+export function token_program_id(): string;