feat(wasm-utxo): expose FixedScriptWallet to API

Add FixedScriptWallet with methods for creating output scripts and addresses
based on wallet keys. This allows working with standard wallet script types
without needing to create descriptors first.

Issue: BTC-2652

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

Author: OttoAllmendinger

packages/wasm-utxo/js/index.ts

@@ -44,6 +44,7 @@ import { Address as WasmAddress } from "./wasm/wasm_utxo";
 export { WrapDescriptor as Descriptor } from "./wasm/wasm_utxo";
 export { WrapMiniscript as Miniscript } from "./wasm/wasm_utxo";
 export { WrapPsbt as Psbt } from "./wasm/wasm_utxo";
+export { FixedScriptWallet } from "./wasm/wasm_utxo";
 
 export namespace utxolibCompat {
   export const Address = WasmAddress;

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

@@ -9,3 +9,43 @@ pub mod test_utils;
 
 pub use wallet_keys::*;
 pub use wallet_scripts::*;
+use wasm_bindgen::prelude::*;
+
+use crate::error::WasmMiniscriptError;
+use crate::try_from_js_value::TryFromJsValue;
+use crate::utxolib_compat::Network;
+
+#[wasm_bindgen]
+pub struct FixedScriptWallet;
+
+#[wasm_bindgen]
+impl FixedScriptWallet {
+    #[wasm_bindgen(js_name = outputScript)]
+    pub fn output_script(
+        keys: JsValue,
+        chain: u32,
+        index: u32,
+    ) -> Result<Vec<u8>, WasmMiniscriptError> {
+        let chain = Chain::try_from(chain)
+            .map_err(|e| WasmMiniscriptError::new(&format!("Invalid chain: {}", e)))?;
+
+        let xpubs = xpub_triple_from_jsvalue(&keys)?;
+        let scripts = WalletScripts::from_xpubs(&xpubs, chain, index);
+        Ok(scripts.output_script().to_bytes())
+    }
+
+    #[wasm_bindgen(js_name = address)]
+    pub fn address(keys: JsValue, chain: u32, index: u32, network: JsValue) -> Result<String, WasmMiniscriptError> {
+        let network = Network::try_from_js_value(&network)?;
+        let xpubs = xpub_triple_from_jsvalue(&keys)?;
+        let chain = Chain::try_from(chain)
+            .map_err(|e| WasmMiniscriptError::new(&format!("Invalid chain: {}", e)))?;
+        let scripts = WalletScripts::from_xpubs(&xpubs, chain, index);
+        let script = scripts.output_script();
+        let address = crate::address::utxolib_compat::from_output_script_with_network(
+            &script, &network,
+        )
+        .map_err(|e| WasmMiniscriptError::new(&format!("Failed to generate address: {}", e)))?;
+        Ok(address.to_string())
+    }
+}

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

@@ -1,11 +1,51 @@
 use std::convert::TryInto;
+use std::str::FromStr;
 
 use crate::bitcoin::{bip32::Xpub, CompressedPublicKey};
+use crate::error::WasmMiniscriptError;
+use wasm_bindgen::JsValue;
 
 pub type XpubTriple = [Xpub; 3];
 
 pub type PubTriple = [CompressedPublicKey; 3];
 
+pub fn xpub_triple_from_jsvalue(keys: &JsValue) -> Result<XpubTriple, WasmMiniscriptError> {
+    let keys_array = js_sys::Array::from(keys);
+    if keys_array.length() != 3 {
+        return Err(WasmMiniscriptError::new("Expected exactly 3 xpub keys"));
+    }
+
+    let key_strings: Result<[String; 3], _> = (0..3)
+        .map(|i| {
+            keys_array.get(i).as_string().ok_or_else(|| {
+                WasmMiniscriptError::new(&format!("Key at index {} is not a string", i))
+            })
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .and_then(|v| {
+            v.try_into()
+                .map_err(|_| WasmMiniscriptError::new("Failed to convert to array"))
+        });
+
+    xpub_triple_from_strings(&key_strings?)
+}
+
+pub fn xpub_triple_from_strings(
+    xpub_strings: &[String; 3],
+) -> Result<XpubTriple, WasmMiniscriptError> {
+    let xpubs: Result<Vec<Xpub>, _> = xpub_strings
+        .iter()
+        .map(|s| {
+            Xpub::from_str(s)
+                .map_err(|e| WasmMiniscriptError::new(&format!("Failed to parse xpub: {}", e)))
+        })
+        .collect();
+
+    xpubs?
+        .try_into()
+        .map_err(|_| WasmMiniscriptError::new("Expected exactly 3 xpubs"))
+}
+
 pub fn to_pub_triple(xpubs: &XpubTriple) -> PubTriple {
     xpubs
         .iter()

packages/wasm-utxo/test/address/utxolibCompat.ts

@@ -3,10 +3,43 @@ import * as fs from "node:fs/promises";
 
 import * as utxolib from "@bitgo/utxo-lib";
 import assert from "node:assert";
-import { utxolibCompat } from "../../js";
+import { utxolibCompat, FixedScriptWallet } from "../../js";
+
+type Triple<T> = [T, T, T];
 
 type Fixture = [type: string, script: string, address: string];
 
+function getAddressUtxoLib(
+  keys: Triple<utxolib.BIP32Interface>,
+  chain: number,
+  index: number,
+  network: utxolib.Network,
+): string {
+  if (!utxolib.bitgo.isChainCode(chain)) {
+    throw new Error(`Invalid chain code: ${chain}`);
+  }
+
+  const walletKeys = new utxolib.bitgo.RootWalletKeys(keys);
+  const derived = walletKeys.deriveForChainAndIndex(chain, index);
+  const script = utxolib.bitgo.outputScripts.createOutputScript2of3(
+    derived.publicKeys,
+    utxolib.bitgo.outputScripts.scriptTypeForChain(chain),
+  );
+  const address = utxolib.address.fromOutputScript(script.scriptPubKey, network);
+  return address;
+}
+
+function getAddressWasm(
+  keys: Triple<utxolib.BIP32Interface>,
+  chain: number,
+  index: number,
+  network: utxolib.Network,
+): string {
+  const xpubs = keys.map((key) => key.neutered().toBase58());
+  const wasmAddress = FixedScriptWallet.address(xpubs, chain, index, network);
+  return wasmAddress;
+}
+
 async function getFixtures(name: string): Promise<Fixture[]> {
   if (name === "bitcoinBitGoSignet") {
     name = "bitcoinPublicSignet";
@@ -34,6 +67,23 @@ function runTest(network: utxolib.Network) {
         assert.deepStrictEqual(Buffer.from(scriptFromAddress), scriptBuf);
       }
     });
+
+    const keyTriple = utxolib.testutil.getKeyTriple("wasm");
+
+    const supportedChainCodes = utxolib.bitgo.chainCodes.filter((chainCode) => {
+      const scriptType = utxolib.bitgo.outputScripts.scriptTypeForChain(chainCode);
+      return utxolib.bitgo.outputScripts.isSupportedScriptType(network, scriptType);
+    });
+
+    it(`can recreate address from wallet keys for chain codes ${supportedChainCodes.join(", ")}`, function () {
+      for (const chainCode of supportedChainCodes) {
+        for (let index = 0; index < 2; index++) {
+          const utxolibAddress = getAddressUtxoLib(keyTriple, chainCode, index, network);
+          const wasmAddress = getAddressWasm(keyTriple, chainCode, index, network);
+          assert.strictEqual(utxolibAddress, wasmAddress);
+        }
+      }
+    });
   });
 }