feat(wasm-utxo): standardize on Rust snake_case and JavaScript camelCase

Update documentation and implementation to follow a consistent naming
convention where:
- Rust WASM bindings use snake_case (Rust convention)
- TypeScript wrappers convert to camelCase (JS convention)

Update BitGoPsbt class implementation to follow this pattern and align
method call sites with the new naming.

Issue: BTC-2652

Co-authored-by: llm-git <[email protected]>

Author: OttoAllmendinger

packages/wasm-utxo/js/README.md

@@ -17,13 +17,15 @@ type-safe API over the raw WASM bindings.
 
    - Generated by `wasm-bindgen` from Rust code
    - Exports classes with static methods (e.g., `AddressNamespace`, `UtxolibCompatNamespace`)
+   - Uses `snake_case` naming (Rust convention)
    - Uses loose types (`any`, `string | null`) due to WASM-bindgen limitations
 
 2. **Namespace Wrapper Files** (e.g., `address.ts`, `utxolibCompat.ts`, `fixedScriptWallet.ts`)
 
    - Import the generated WASM namespace classes
    - Define precise TypeScript types to replace `any` types
    - Export individual functions that wrap the static WASM methods
+   - Convert `snake_case` WASM methods to `camelCase` (JavaScript convention)
    - Re-export related types for convenience
 
 3. **Shared Type Files** (e.g., `coinName.ts`, `triple.ts`)
@@ -42,8 +44,9 @@ type-safe API over the raw WASM bindings.
 Given a WASM-generated class:
 
 ```typescript
-// wasm/wasm_utxo.d.ts (generated)
+// wasm/wasm_utxo.d.ts (generated by wasm-bindgen)
 export class AddressNamespace {
+  // Note: snake_case naming from Rust
   static to_output_script_with_coin(address: string, coin: string): Uint8Array;
   static from_output_script_with_coin(
     script: Uint8Array,
@@ -53,7 +56,7 @@ export class AddressNamespace {
 }
 ```
 
-We create a wrapper module:
+We create a wrapper module that provides better types and camelCase naming:
 
 ```typescript
 // address.ts
@@ -62,7 +65,9 @@ import type { CoinName } from "./coinName";
 
 export type AddressFormat = "default" | "cashaddr";
 
+// Wrapper provides camelCase naming and precise types
 export function toOutputScriptWithCoin(address: string, coin: CoinName): Uint8Array {
+  // Calls snake_case WASM method
   return AddressNamespace.to_output_script_with_coin(address, coin);
 }
 
@@ -71,6 +76,7 @@ export function fromOutputScriptWithCoin(
   coin: CoinName,
   format?: AddressFormat,
 ): string {
+  // Calls snake_case WASM method
   return AddressNamespace.from_output_script_with_coin(script, coin, format);
 }
 ```
@@ -85,5 +91,7 @@ export * as address from "./address";
 ### Benefits
 
 - **Type Safety**: Replace loose `any` and `string` types with precise union types
-- **Better DX**: IDE autocomplete works better with concrete types
+- **Idiomatic Naming**: Each layer uses its native convention (`snake_case` in Rust, `camelCase` in JavaScript)
+- **Better DX**: IDE autocomplete works better with concrete types and familiar naming
 - **Maintainability**: Centralized type definitions prevent duplication
+- **Clear Separation**: WASM bindings stay pure to Rust conventions, TypeScript handles JS conventions

packages/wasm-utxo/js/fixedScriptWallet.ts

@@ -90,7 +90,7 @@ export class BitGoPsbt {
    * @returns A BitGoPsbt instance
    */
   static fromBytes(bytes: Uint8Array, network: NetworkName): BitGoPsbt {
-    const wasm = WasmBitGoPsbt.fromBytes(bytes, network);
+    const wasm = WasmBitGoPsbt.from_bytes(bytes, network);
     return new BitGoPsbt(wasm);
   }
 
@@ -104,7 +104,7 @@ export class BitGoPsbt {
     walletKeys: WalletKeys,
     replayProtection: ReplayProtection,
   ): ParsedTransaction {
-    return this.wasm.parseTransactionWithWalletKeys(walletKeys, replayProtection);
+    return this.wasm.parse_transaction_with_wallet_keys(walletKeys, replayProtection);
   }
 
   /**
@@ -119,6 +119,6 @@ export class BitGoPsbt {
    * @note This method does NOT validate wallet inputs. It only parses outputs.
    */
   parseOutputsWithWalletKeys(walletKeys: WalletKeys): ParsedOutput[] {
-    return this.wasm.parseOutputsWithWalletKeys(walletKeys);
+    return this.wasm.parse_outputs_with_wallet_keys(walletKeys);
   }
 }

packages/wasm-utxo/src/wasm-bindgen.md

@@ -66,20 +66,23 @@ pub use fixed_script_wallet::FixedScriptWalletNamespace;
 
 4. **Methods**: All functions are static methods on the namespace struct
 
-5. **Case**: Use `snake_case` for method names (Rust convention) - they'll be available as both `snake_case` and `camelCase` in JavaScript
+5. **Case**: Use `snake_case` for method names (Rust convention) - TypeScript wrappers will provide `camelCase` versions
 
-6. **Error Handling**: Return `Result<T, JsValue>` types - `wasm-bindgen` automatically converts these to JavaScript exceptions
+6. **No `js_name` Attributes**: Do NOT use `#[wasm_bindgen(js_name = "...")]` to rename methods - keep Rust names pure and let TypeScript wrappers handle JS naming conventions
 
-7. **Separation**: WASM binding layer delegates to core implementation in domain modules (e.g., `src/address/`, `src/fixed_script_wallet/`)
+7. **Error Handling**: Return `Result<T, JsValue>` types - `wasm-bindgen` automatically converts these to JavaScript exceptions
+
+8. **Separation**: WASM binding layer delegates to core implementation in domain modules (e.g., `src/address/`, `src/fixed_script_wallet/`)
 
 ### Generated TypeScript
 
-The Rust namespace struct becomes a TypeScript class with static methods:
+The Rust namespace struct becomes a TypeScript class with static methods (using `snake_case` from Rust):
 
 ```typescript
 // wasm/wasm_utxo.d.ts (generated by wasm-bindgen)
 export class AddressNamespace {
   private constructor();
+  // Note: snake_case naming preserved from Rust
   static to_output_script_with_coin(address: string, coin: string): Uint8Array;
   static from_output_script_with_coin(
     script: Uint8Array,
@@ -91,31 +94,33 @@ export class AddressNamespace {
 
 ### TypeScript Wrapper Layer
 
-The generated types have limitations (loose types like `any`, `string | null`). We wrap them with better TypeScript types in the `js/` directory.
+The generated types have limitations (loose types like `any`, `string | null`, `snake_case` naming). We wrap them with better TypeScript types in the `js/` directory.
 
 **See `../js/README.md` for the complete TypeScript wrapper pattern.**
 
 The wrapper layer:
 
 - Imports the generated namespace classes
 - Defines precise TypeScript types (e.g., union types instead of `string`)
+- Converts `snake_case` method names to `camelCase` (JavaScript convention)
 - Exports wrapper functions with strong type signatures
 - Provides better IDE support and compile-time type checking
 
 ### Example Flow
 
 1. **Core Implementation**: Business logic in domain modules (e.g., `src/address/networks.rs`)
-2. **WASM Bindings**: Define `AddressNamespace` struct with static methods in `src/wasm/address.rs` that calls into core implementation
+2. **WASM Bindings**: Define `AddressNamespace` struct with `snake_case` methods in `src/wasm/address.rs` that calls into core implementation
 3. **Module Export**: Export namespace from `src/wasm/mod.rs`
-4. **wasm-bindgen Generation**: Generates `AddressNamespace` class in `wasm/wasm_utxo.d.ts`
-5. **TypeScript Wrapper**: `js/address.ts` wraps it with precise types
+4. **wasm-bindgen Generation**: Generates `AddressNamespace` class with `snake_case` methods in `wasm/wasm_utxo.d.ts`
+5. **TypeScript Wrapper**: `js/address.ts` wraps it with precise types and `camelCase` naming
 6. **Main Export**: `js/index.ts` exports it as `export * as address from "./address"`
 
 This layered approach gives us:
 
 - Clear separation between core implementation and WASM bindings
-- Automatic WASM bindings generation
-- Type-safe, well-documented TypeScript API
+- Automatic WASM bindings generation with Rust conventions
+- Type-safe, well-documented TypeScript API with JavaScript conventions
+- Each layer remains idiomatic to its language
 
 ## Type Mapping
 
@@ -139,12 +144,14 @@ Common Rust ↔ JavaScript type mappings:
 
 3. **Use descriptive namespace names** - Clear what domain they cover (e.g., `AddressNamespace`, `PsbtNamespace`)
 
-4. **Thin binding layer** - WASM methods should delegate to core implementation, only handling type conversions
+4. **Use `snake_case` naming only** - Never use `#[wasm_bindgen(js_name = "...")]` to convert to camelCase - let TypeScript wrappers handle naming conversion
+
+5. **Thin binding layer** - WASM methods should delegate to core implementation, only handling type conversions
 
-5. **Return `Result<T, JsValue>` types** - Let `wasm-bindgen` handle error conversion to JavaScript exceptions
+6. **Return `Result<T, JsValue>` types** - Let `wasm-bindgen` handle error conversion to JavaScript exceptions
 
-6. **Avoid complex types in signatures** - Stick to primitives and byte arrays when possible; use `JsValue` for complex types
+7. **Avoid complex types in signatures** - Stick to primitives and byte arrays when possible; use `JsValue` for complex types
 
-7. **Document with Rust doc comments** - They'll appear in the generated TypeScript
+8. **Document with Rust doc comments** - They'll appear in the generated TypeScript
 
-8. **Coordinate with TypeScript wrappers** - Keep the wrapper layer in mind when designing the Rust API
+9. **Coordinate with TypeScript wrappers** - Keep the wrapper layer in mind when designing the Rust API

packages/wasm-utxo/src/wasm/fixed_script_wallet.rs

@@ -137,7 +137,6 @@ pub struct BitGoPsbt {
 #[wasm_bindgen]
 impl BitGoPsbt {
     /// Deserialize a PSBT from bytes with network-specific logic
-    #[wasm_bindgen(js_name = fromBytes)]
     pub fn from_bytes(bytes: &[u8], network: &str) -> Result<BitGoPsbt, WasmUtxoError> {
         let network = parse_network(network)?;
 
@@ -149,7 +148,6 @@ impl BitGoPsbt {
     }
 
     /// Parse transaction with wallet keys to identify wallet inputs/outputs
-    #[wasm_bindgen(js_name = parseTransactionWithWalletKeys)]
     pub fn parse_transaction_with_wallet_keys(
         &self,
         wallet_keys: JsValue,
@@ -175,7 +173,6 @@ impl BitGoPsbt {
     /// Parse outputs with wallet keys to identify which outputs belong to a wallet
     ///
     /// Note: This method does NOT validate wallet inputs. It only parses outputs.
-    #[wasm_bindgen(js_name = parseOutputsWithWalletKeys)]
     pub fn parse_outputs_with_wallet_keys(
         &self,
         wallet_keys: JsValue,