feat(wasm-solana): return Transaction types from builder functions

Changed buildTransaction() and buildFromVersionedData() to return
Transaction and VersionedTransaction objects instead of raw bytes.
This allows callers to inspect the transaction before serializing,
which is more ergonomic and matches the existing Transaction API.

Callers that need bytes can simply call .toBytes() on the result.

Author: lcovar

packages/wasm-solana/js/builder.ts

@@ -6,6 +6,8 @@
  */
 
 import { BuilderNamespace } from "./wasm/wasm_solana.js";
+import { Transaction } from "./transaction.js";
+import { VersionedTransaction } from "./versioned.js";
 
 // =============================================================================
 // Nonce Types
@@ -463,48 +465,58 @@ export interface TransactionIntent {
 /**
  * Build a Solana transaction from a high-level intent.
  *
- * This function takes a declarative TransactionIntent and produces serialized
- * transaction bytes that can be signed and submitted to the network.
+ * This function takes a declarative TransactionIntent and produces a Transaction
+ * object that can be inspected, signed, and serialized.
  *
- * The returned transaction is unsigned - signatures should be added before
- * broadcasting.
+ * The returned transaction is unsigned - signatures should be added via
+ * `addSignature()` before serializing with `toBytes()` and broadcasting.
  *
  * @param intent - The transaction intent describing what to build
- * @returns Serialized unsigned transaction bytes (Uint8Array)
+ * @returns A Transaction object that can be inspected, signed, and serialized
  * @throws Error if the intent cannot be built (e.g., invalid addresses)
  *
  * @example
  * ```typescript
  * import { buildTransaction } from '@bitgo/wasm-solana';
  *
  * // Build a simple SOL transfer
- * const txBytes = buildTransaction({
+ * const tx = buildTransaction({
  *   feePayer: sender,
  *   nonce: { type: 'blockhash', value: blockhash },
  *   instructions: [
- *     { type: 'transfer', from: sender, to: recipient, lamports: '1000000' }
+ *     { type: 'transfer', from: sender, to: recipient, lamports: 1000000n }
  *   ]
  * });
  *
- * // The returned bytes can be signed and broadcast
+ * // Inspect the transaction
+ * console.log(tx.feePayer);
+ * console.log(tx.recentBlockhash);
+ *
+ * // Get the signable payload for signing
+ * const payload = tx.signablePayload();
+ *
+ * // Add signature and serialize
+ * tx.addSignature(signerPubkey, signature);
+ * const txBytes = tx.toBytes();
  * ```
  *
  * @example
  * ```typescript
  * // Build with durable nonce and priority fee
- * const txBytes = buildTransaction({
+ * const tx = buildTransaction({
  *   feePayer: sender,
  *   nonce: { type: 'durable', address: nonceAccount, authority: sender, value: nonceValue },
  *   instructions: [
  *     { type: 'computeBudget', unitLimit: 200000, unitPrice: 5000 },
- *     { type: 'transfer', from: sender, to: recipient, lamports: '1000000' },
+ *     { type: 'transfer', from: sender, to: recipient, lamports: 1000000n },
  *     { type: 'memo', message: 'BitGo transfer' }
  *   ]
  * });
  * ```
  */
-export function buildTransaction(intent: TransactionIntent): Uint8Array {
-  return BuilderNamespace.build_transaction(intent);
+export function buildTransaction(intent: TransactionIntent): Transaction {
+  const wasm = BuilderNamespace.build_transaction(intent);
+  return Transaction.fromWasm(wasm);
 }
 
 // =============================================================================
@@ -560,17 +572,17 @@ export interface RawVersionedTransactionData {
  *
  * 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.
+ * is needed - we just serialize the raw structure.
  *
  * @param data - Raw versioned transaction data
- * @returns Serialized unsigned versioned transaction bytes (Uint8Array)
+ * @returns A VersionedTransaction object that can be inspected, signed, and serialized
  * @throws Error if the data is invalid
  *
  * @example
  * ```typescript
  * import { buildFromVersionedData } from '@bitgo/wasm-solana';
  *
- * const txBytes = buildFromVersionedData({
+ * const tx = buildFromVersionedData({
  *   staticAccountKeys: ['pubkey1', 'pubkey2', ...],
  *   addressLookupTables: [
  *     { accountKey: 'altPubkey', writableIndexes: [0, 1], readonlyIndexes: [2] }
@@ -585,8 +597,14 @@ export interface RawVersionedTransactionData {
  *   },
  *   recentBlockhash: 'blockhash'
  * });
+ *
+ * // Inspect, sign, and serialize
+ * console.log(tx.feePayer);
+ * tx.addSignature(signerPubkey, signature);
+ * const txBytes = tx.toBytes();
  * ```
  */
-export function buildFromVersionedData(data: RawVersionedTransactionData): Uint8Array {
-  return BuilderNamespace.build_from_versioned_data(data);
+export function buildFromVersionedData(data: RawVersionedTransactionData): VersionedTransaction {
+  const wasm = BuilderNamespace.build_from_versioned_data(data);
+  return VersionedTransaction.fromWasm(wasm);
 }

packages/wasm-solana/js/transaction.ts

@@ -57,6 +57,14 @@ export class Transaction {
     return new Transaction(wasm);
   }
 
+  /**
+   * Create a Transaction from a WasmTransaction instance.
+   * @internal Used by builder functions
+   */
+  static fromWasm(wasm: WasmTransaction): Transaction {
+    return new Transaction(wasm);
+  }
+
   /**
    * Get the fee payer address as a base58 string
    * Returns null if there are no account keys (shouldn't happen for valid transactions)

packages/wasm-solana/js/versioned.ts

@@ -90,6 +90,14 @@ export class VersionedTransaction {
     return VersionedTransaction.fromBytes(bytes);
   }
 
+  /**
+   * Create a VersionedTransaction from a WasmVersionedTransaction instance.
+   * @internal Used by builder functions
+   */
+  static fromWasm(wasm: WasmVersionedTransaction): VersionedTransaction {
+    return new VersionedTransaction(wasm);
+  }
+
   /**
    * Create a versioned transaction from raw MessageV0 data.
    *
@@ -120,10 +128,9 @@ export class VersionedTransaction {
    * ```
    */
   static fromVersionedData(data: RawVersionedTransactionData): VersionedTransaction {
-    // Build the transaction bytes using WASM
-    const bytes = BuilderNamespace.build_from_versioned_data(data);
-    // Parse the bytes to create a VersionedTransaction
-    return VersionedTransaction.fromBytes(bytes);
+    // Build the transaction using WASM and wrap in TypeScript class
+    const wasm = BuilderNamespace.build_from_versioned_data(data);
+    return VersionedTransaction.fromWasm(wasm);
   }
 
   /**

packages/wasm-solana/src/wasm/builder.rs

@@ -1,10 +1,11 @@
 //! WASM binding for transaction building.
 //!
 //! Exposes transaction building functions:
-//! - `buildTransaction` - Creates transactions from a high-level intent structure
-//! - `buildFromVersionedData` - Creates versioned transactions from raw MessageV0 data
+//! - `buildTransaction` - Creates a Transaction from a high-level intent structure
+//! - `buildFromVersionedData` - Creates a VersionedTransaction from raw MessageV0 data
 
 use crate::builder;
+use crate::wasm::transaction::{WasmTransaction, WasmVersionedTransaction};
 use wasm_bindgen::prelude::*;
 
 /// Namespace for transaction building operations.
@@ -46,22 +47,26 @@ impl BuilderNamespace {
     ///
     /// # Returns
     ///
-    /// Serialized unsigned transaction bytes (Uint8Array).
+    /// 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.
+    /// filled in later by signing via `addSignature()`.
     ///
     /// @param intent - The transaction intent as a JSON object
-    /// @returns Serialized transaction bytes
+    /// @returns Transaction object
     #[wasm_bindgen]
-    pub fn build_transaction(intent: JsValue) -> Result<Vec<u8>, JsValue> {
+    pub fn build_transaction(intent: JsValue) -> Result<WasmTransaction, JsValue> {
         // Deserialize the intent from JavaScript
         let intent: builder::TransactionIntent =
             serde_wasm_bindgen::from_value(intent).map_err(|e| {
                 JsValue::from_str(&format!("Failed to parse transaction intent: {}", e))
             })?;
 
-        // Build the transaction
-        builder::build_transaction(intent).map_err(|e| JsValue::from_str(&e.to_string()))
+        // Build the transaction bytes
+        let bytes =
+            builder::build_transaction(intent).map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        // Wrap in WasmTransaction for rich API access
+        WasmTransaction::from_bytes(&bytes).map_err(|e| JsValue::from_str(&e.to_string()))
     }
 
     /// Build a versioned transaction directly from raw MessageV0 data.
@@ -91,9 +96,9 @@ impl BuilderNamespace {
     /// ```
     ///
     /// @param data - Raw versioned transaction data as a JSON object
-    /// @returns Serialized versioned transaction bytes (unsigned)
+    /// @returns VersionedTransaction object
     #[wasm_bindgen]
-    pub fn build_from_versioned_data(data: JsValue) -> Result<Vec<u8>, JsValue> {
+    pub fn build_from_versioned_data(data: JsValue) -> Result<WasmVersionedTransaction, JsValue> {
         // Deserialize the raw versioned data from JavaScript
         let data: builder::RawVersionedTransactionData = serde_wasm_bindgen::from_value(data)
             .map_err(|e| {
@@ -103,7 +108,11 @@ impl BuilderNamespace {
                 ))
             })?;
 
-        // Build the versioned transaction
-        builder::build_from_raw_versioned_data(&data).map_err(|e| JsValue::from_str(&e.to_string()))
+        // Build the versioned transaction bytes
+        let bytes = builder::build_from_raw_versioned_data(&data)
+            .map_err(|e| JsValue::from_str(&e.to_string()))?;
+
+        // Wrap in WasmVersionedTransaction for rich API access
+        WasmVersionedTransaction::from_bytes(&bytes).map_err(|e| JsValue::from_str(&e.to_string()))
     }
 }