@bitgo/wasm-solana 1.5.0 → 2.0.0

package/dist/esm/js/intentBuilder.d.ts

@@ -0,0 +1,197 @@
+/**
+ * High-level intent-based transaction building.
+ *
+ * This module provides `buildFromIntent()` which accepts BitGo intent objects
+ * directly and builds Solana transactions without requiring the caller to
+ * construct low-level instructions.
+ *
+ * The intent → transaction mapping happens entirely in Rust/WASM for simplicity.
+ *
+ * Usage:
+ * ```typescript
+ * import { buildFromIntent } from '@bitgo/wasm-solana';
+ *
+ * const result = buildFromIntent(intent, {
+ *   feePayer: walletRootAddress,
+ *   nonce: { type: 'blockhash', value: recentBlockhash },
+ * });
+ *
+ * // result.transaction - Transaction object
+ * // result.generatedKeypairs - any keypairs generated (e.g., stake accounts)
+ * ```
+ */
+import { Transaction } from "./transaction.js";
+/** Nonce source - blockhash or durable nonce */
+export type NonceSource = BlockhashNonce | DurableNonce;
+export interface BlockhashNonce {
+    type: "blockhash";
+    value: string;
+}
+export interface DurableNonce {
+    type: "durable";
+    address: string;
+    authority: string;
+    value: string;
+}
+/** Parameters for building a transaction from intent */
+export interface BuildFromIntentParams {
+    /** Fee payer address (wallet root) */
+    feePayer: string;
+    /** Nonce source - blockhash or durable nonce */
+    nonce: NonceSource;
+}
+/** A keypair generated during transaction building */
+export interface GeneratedKeypair {
+    /** Purpose of this keypair */
+    purpose: "stakeAccount" | "unstakeAccount" | "transferAuthority";
+    /** Public address (base58) */
+    address: string;
+    /** Secret key (base58) */
+    secretKey: string;
+}
+/** Result from building a transaction from intent */
+export interface BuildFromIntentResult {
+    /** The built transaction */
+    transaction: Transaction;
+    /** Generated keypairs (for stake accounts, etc.) */
+    generatedKeypairs: GeneratedKeypair[];
+}
+/** Base intent - all intents have intentType */
+export interface BaseIntent {
+    intentType: string;
+    memo?: string;
+}
+/** Payment intent */
+export interface PaymentIntent extends BaseIntent {
+    intentType: "payment";
+    recipients?: Array<{
+        address?: {
+            address: string;
+        };
+        amount?: {
+            value: bigint;
+            symbol?: string;
+        };
+    }>;
+}
+/** Stake intent */
+export interface StakeIntent extends BaseIntent {
+    intentType: "stake";
+    validatorAddress: string;
+    amount?: {
+        value: bigint;
+    };
+    stakingType?: "NATIVE" | "JITO" | "MARINADE";
+    stakePoolConfig?: StakePoolConfig;
+}
+/** Stake pool configuration (for Jito) */
+export interface StakePoolConfig {
+    stakePoolAddress: string;
+    withdrawAuthority: string;
+    reserveStake: string;
+    destinationPoolAccount: string;
+    managerFeeAccount: string;
+    referralPoolAccount?: string;
+    poolMint: string;
+    validatorList?: string;
+    sourcePoolAccount?: string;
+}
+/** Unstake intent */
+export interface UnstakeIntent extends BaseIntent {
+    intentType: "unstake";
+    stakingAddress: string;
+    validatorAddress?: string;
+    amount?: {
+        value: bigint;
+    };
+    remainingStakingAmount?: {
+        value: bigint;
+    };
+    stakingType?: "NATIVE" | "JITO" | "MARINADE";
+    stakePoolConfig?: StakePoolConfig;
+}
+/** Claim intent (withdraw from deactivated stake) */
+export interface ClaimIntent extends BaseIntent {
+    intentType: "claim";
+    stakingAddress: string;
+    amount?: {
+        value: bigint;
+    };
+}
+/** Deactivate intent */
+export interface DeactivateIntent extends BaseIntent {
+    intentType: "deactivate";
+    stakingAddress?: string;
+    stakingAddresses?: string[];
+}
+/** Delegate intent */
+export interface DelegateIntent extends BaseIntent {
+    intentType: "delegate";
+    validatorAddress: string;
+    stakingAddress?: string;
+    stakingAddresses?: string[];
+}
+/** Enable token intent (create ATA) */
+export interface EnableTokenIntent extends BaseIntent {
+    intentType: "enableToken";
+    recipientAddress?: string;
+    tokenAddress?: string;
+    tokenProgramId?: string;
+}
+/** Close ATA intent */
+export interface CloseAtaIntent extends BaseIntent {
+    intentType: "closeAssociatedTokenAccount";
+    tokenAccountAddress?: string;
+    tokenProgramId?: string;
+}
+/** Consolidate intent - transfer from child address to root */
+export interface ConsolidateIntent extends BaseIntent {
+    intentType: "consolidate";
+    /** The child address to consolidate from (sender) */
+    receiveAddress: string;
+    /** Recipients (root address for SOL, ATAs for tokens) */
+    recipients?: Array<{
+        address?: {
+            address: string;
+        };
+        amount?: {
+            value: bigint;
+        };
+    }>;
+}
+/** Union of all supported intent types */
+export type SolanaIntent = PaymentIntent | StakeIntent | UnstakeIntent | ClaimIntent | DeactivateIntent | DelegateIntent | EnableTokenIntent | CloseAtaIntent | ConsolidateIntent;
+/**
+ * Build a Solana transaction from a BitGo intent.
+ *
+ * This function passes the intent directly to Rust/WASM which handles
+ * all the intent-to-transaction mapping internally.
+ *
+ * @param intent - The BitGo intent (with intentType, etc.)
+ * @param params - Build parameters (feePayer, nonce)
+ * @returns Transaction object and any generated keypairs
+ *
+ * @example
+ * ```typescript
+ * // Payment intent
+ * const result = buildFromIntent(
+ *   {
+ *     intentType: 'payment',
+ *     recipients: [{ address: { address: recipient }, amount: { value: 1000000n } }]
+ *   },
+ *   { feePayer: walletRoot, nonce: { type: 'blockhash', value: blockhash } }
+ * );
+ *
+ * // Native staking - generates a new stake account keypair
+ * const result = buildFromIntent(
+ *   {
+ *     intentType: 'stake',
+ *     validatorAddress: validator,
+ *     amount: { value: 1000000000n }
+ *   },
+ *   { feePayer: walletRoot, nonce: { type: 'blockhash', value: blockhash } }
+ * );
+ * // result.generatedKeypairs[0] contains the stake account keypair
+ * ```
+ */
+export declare function buildFromIntent(intent: BaseIntent, params: BuildFromIntentParams): BuildFromIntentResult;

package/dist/esm/js/intentBuilder.js

@@ -0,0 +1,67 @@
+/**
+ * High-level intent-based transaction building.
+ *
+ * This module provides `buildFromIntent()` which accepts BitGo intent objects
+ * directly and builds Solana transactions without requiring the caller to
+ * construct low-level instructions.
+ *
+ * The intent → transaction mapping happens entirely in Rust/WASM for simplicity.
+ *
+ * Usage:
+ * ```typescript
+ * import { buildFromIntent } from '@bitgo/wasm-solana';
+ *
+ * const result = buildFromIntent(intent, {
+ *   feePayer: walletRootAddress,
+ *   nonce: { type: 'blockhash', value: recentBlockhash },
+ * });
+ *
+ * // result.transaction - Transaction object
+ * // result.generatedKeypairs - any keypairs generated (e.g., stake accounts)
+ * ```
+ */
+import { IntentNamespace } from "./wasm/wasm_solana.js";
+import { Transaction } from "./transaction.js";
+// =============================================================================
+// Main Function
+// =============================================================================
+/**
+ * Build a Solana transaction from a BitGo intent.
+ *
+ * This function passes the intent directly to Rust/WASM which handles
+ * all the intent-to-transaction mapping internally.
+ *
+ * @param intent - The BitGo intent (with intentType, etc.)
+ * @param params - Build parameters (feePayer, nonce)
+ * @returns Transaction object and any generated keypairs
+ *
+ * @example
+ * ```typescript
+ * // Payment intent
+ * const result = buildFromIntent(
+ *   {
+ *     intentType: 'payment',
+ *     recipients: [{ address: { address: recipient }, amount: { value: 1000000n } }]
+ *   },
+ *   { feePayer: walletRoot, nonce: { type: 'blockhash', value: blockhash } }
+ * );
+ *
+ * // Native staking - generates a new stake account keypair
+ * const result = buildFromIntent(
+ *   {
+ *     intentType: 'stake',
+ *     validatorAddress: validator,
+ *     amount: { value: 1000000000n }
+ *   },
+ *   { feePayer: walletRoot, nonce: { type: 'blockhash', value: blockhash } }
+ * );
+ * // result.generatedKeypairs[0] contains the stake account keypair
+ * ```
+ */
+export function buildFromIntent(intent, params) {
+    const result = IntentNamespace.build_from_intent(intent, params);
+    return {
+        transaction: Transaction.fromWasm(result.transaction),
+        generatedKeypairs: result.generatedKeypairs,
+    };
+}

package/dist/esm/js/keypair.d.ts

@@ -8,6 +8,11 @@ import { WasmKeypair } from "./wasm/wasm_solana.js";
 export declare class Keypair {
     private _wasm;
     private constructor();
+    /**
+     * Generate a new random keypair
+     * @returns A new Keypair instance with randomly generated keys
+     */
+    static generate(): Keypair;
     /**
      * Create a keypair from a 32-byte secret key
      * @param secretKey - The 32-byte Ed25519 secret key

package/dist/esm/js/keypair.js

@@ -10,6 +10,14 @@ export class Keypair {
     constructor(_wasm) {
         this._wasm = _wasm;
     }
+    /**
+     * Generate a new random keypair
+     * @returns A new Keypair instance with randomly generated keys
+     */
+    static generate() {
+        const wasm = WasmKeypair.generate();
+        return new Keypair(wasm);
+    }
     /**
      * Create a keypair from a 32-byte secret key
      * @param secretKey - The 32-byte Ed25519 secret key

package/dist/esm/js/transaction.d.ts

@@ -72,7 +72,7 @@ export declare class Transaction {
      * Get the transaction ID (first signature as base58).
      *
      * For Solana, the transaction ID is the first signature.
-     * Returns "UNSIGNED" if the transaction has no valid signatures.
+     * Returns `undefined` if the transaction is unsigned (no signatures or all-zeros signature).
      *
      * @example
      * ```typescript
@@ -81,7 +81,7 @@ export declare class Transaction {
      * console.log(tx.id); // Base58 encoded signature
      * ```
      */
-    get id(): string;
+    get id(): string | undefined;
     /**
      * Get the signable message payload (what gets signed)
      * This is the serialized message that signers sign
@@ -91,10 +91,9 @@ export declare class Transaction {
     /**
      * Serialize the message portion of the transaction.
      * Alias for signablePayload() - provides compatibility with @solana/web3.js API.
-     * Returns a Buffer for compatibility with code expecting .toString('base64').
-     * @returns The serialized message bytes as a Buffer
+     * @returns The serialized message bytes
      */
-    serializeMessage(): Buffer;
+    serializeMessage(): Uint8Array;
     /**
      * Serialize the transaction to bytes
      * @returns The serialized transaction bytes

package/dist/esm/js/transaction.js

@@ -63,7 +63,7 @@ export class Transaction {
      * Get the transaction ID (first signature as base58).
      *
      * For Solana, the transaction ID is the first signature.
-     * Returns "UNSIGNED" if the transaction has no valid signatures.
+     * Returns `undefined` if the transaction is unsigned (no signatures or all-zeros signature).
      *
      * @example
      * ```typescript
@@ -86,11 +86,10 @@ export class Transaction {
     /**
      * Serialize the message portion of the transaction.
      * Alias for signablePayload() - provides compatibility with @solana/web3.js API.
-     * Returns a Buffer for compatibility with code expecting .toString('base64').
-     * @returns The serialized message bytes as a Buffer
+     * @returns The serialized message bytes
      */
     serializeMessage() {
-        return Buffer.from(this.signablePayload());
+        return this.signablePayload();
     }
     /**
      * Serialize the transaction to bytes

package/dist/esm/js/versioned.d.ts

@@ -63,10 +63,6 @@ export declare class VersionedTransaction {
      * Automatically handles both legacy and versioned formats.
      */
     static fromBytes(bytes: Uint8Array): VersionedTransaction;
-    /**
-     * Deserialize a transaction from base64 string.
-     */
-    static fromBase64(base64: string): VersionedTransaction;
     /**
      * Create a VersionedTransaction from a WasmVersionedTransaction instance.
      * @internal Used by builder functions
@@ -126,9 +122,9 @@ export declare class VersionedTransaction {
      * Get the transaction ID (first signature as base58).
      *
      * For Solana, the transaction ID is the first signature.
-     * Returns "UNSIGNED" if the transaction has no valid signatures.
+     * Returns `undefined` if the transaction is unsigned (no signatures or all-zeros signature).
      */
-    get id(): string;
+    get id(): string | undefined;
     /**
      * Get the signable message payload.
      */
@@ -136,18 +132,13 @@ export declare class VersionedTransaction {
     /**
      * Serialize the message portion of the transaction.
      * Alias for signablePayload() - provides compatibility with @solana/web3.js API.
-     * Returns a Buffer for compatibility with code expecting .toString('base64').
-     * @returns The serialized message bytes as a Buffer
+     * @returns The serialized message bytes
      */
-    serializeMessage(): Buffer;
+    serializeMessage(): Uint8Array;
     /**
      * Serialize the transaction to bytes.
      */
     toBytes(): Uint8Array;
-    /**
-     * Serialize the transaction to base64.
-     */
-    toBase64(): string;
     /**
      * Serialize to network broadcast format.
      * @returns The transaction as bytes ready for broadcast

package/dist/esm/js/versioned.js

@@ -33,13 +33,6 @@ export class VersionedTransaction {
     static fromBytes(bytes) {
         return new VersionedTransaction(WasmVersionedTransaction.from_bytes(bytes));
     }
-    /**
-     * Deserialize a transaction from base64 string.
-     */
-    static fromBase64(base64) {
-        const bytes = Uint8Array.from(Buffer.from(base64, "base64"));
-        return VersionedTransaction.fromBytes(bytes);
-    }
     /**
      * Create a VersionedTransaction from a WasmVersionedTransaction instance.
      * @internal Used by builder functions
@@ -115,7 +108,7 @@ export class VersionedTransaction {
      * Get the transaction ID (first signature as base58).
      *
      * For Solana, the transaction ID is the first signature.
-     * Returns "UNSIGNED" if the transaction has no valid signatures.
+     * Returns `undefined` if the transaction is unsigned (no signatures or all-zeros signature).
      */
     get id() {
         return this.inner.id;
@@ -129,11 +122,10 @@ export class VersionedTransaction {
     /**
      * Serialize the message portion of the transaction.
      * Alias for signablePayload() - provides compatibility with @solana/web3.js API.
-     * Returns a Buffer for compatibility with code expecting .toString('base64').
-     * @returns The serialized message bytes as a Buffer
+     * @returns The serialized message bytes
      */
     serializeMessage() {
-        return Buffer.from(this.signablePayload());
+        return this.signablePayload();
     }
     /**
      * Serialize the transaction to bytes.
@@ -141,12 +133,6 @@ export class VersionedTransaction {
     toBytes() {
         return this.inner.to_bytes();
     }
-    /**
-     * Serialize the transaction to base64.
-     */
-    toBase64() {
-        return Buffer.from(this.toBytes()).toString("base64");
-    }
     /**
      * Serialize to network broadcast format.
      * @returns The transaction as bytes ready for broadcast

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

@@ -372,6 +372,48 @@ export class Instructions {
   push(instruction: Instruction): void;
 }
 
+export class IntentNamespace {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Build a transaction directly from a BitGo intent.
+   *
+   * This function takes the full intent as-is and builds the transaction
+   * without requiring the caller to construct instructions.
+   *
+   * # Arguments
+   *
+   * * `intent` - The full BitGo intent object (with intentType, etc.)
+   * * `params` - Build parameters: { feePayer, nonce }
+   *
+   * # Returns
+   *
+   * An object with:
+   * * `transaction` - WasmTransaction object
+   * * `generatedKeypairs` - Array of keypairs generated (for stake accounts, etc.)
+   *
+   * # Example
+   *
+   * ```javascript
+   * const result = IntentNamespace.build_from_intent(
+   *   {
+   *     intentType: 'stake',
+   *     validatorAddress: '...',
+   *     amount: { value: 1000000000n }
+   *   },
+   *   {
+   *     feePayer: 'DgT9...',
+   *     nonce: { type: 'blockhash', value: 'GWaQ...' }
+   *   }
+   * );
+   * // result.transaction - WasmTransaction object
+   * // result.generatedKeypairs - [{ purpose, address, secretKey }]
+   * ```
+   */
+  static build_from_intent(intent: any, params: any): any;
+}
+
 export class Keypair {
   free(): void;
   [Symbol.dispose](): void;
@@ -697,6 +739,10 @@ export class WasmKeypair {
    * Get the address as a base58 string.
    */
   address(): string;
+  /**
+   * Generate a new random keypair.
+   */
+  static generate(): WasmKeypair;
   /**
    * Get the public key as a base58 string.
    */
@@ -808,9 +854,9 @@ export class WasmTransaction {
    * Get the transaction ID (first signature as base58).
    *
    * For Solana, the transaction ID is the first signature.
-   * Returns "UNSIGNED" if the first signature is all zeros (unsigned transaction).
+   * Returns `undefined` if the transaction is unsigned (no signatures or all-zeros signature).
    */
-  readonly id: string;
+  readonly id: string | undefined;
   /**
    * Get the fee payer address as a base58 string.
    *
@@ -902,9 +948,9 @@ export class WasmVersionedTransaction {
    * Get the transaction ID (first signature as base58).
    *
    * For Solana, the transaction ID is the first signature.
-   * Returns "UNSIGNED" if the first signature is all zeros (unsigned transaction).
+   * Returns `undefined` if the transaction is unsigned (no signatures or all-zeros signature).
    */
-  readonly id: string;
+  readonly id: string | undefined;
   /**
    * Get the fee payer address as a base58 string.
    */