feat(wasm-utxo): add ScriptType enum and supportsScriptType function

Add standalone ScriptType API for fixed-script wallets:
- Add ScriptType enum (p2sh, p2shP2wsh, p2wsh, p2tr, p2trMusig2)
- Add supports_script_type method to OutputScriptSupport
- Expose supportsScriptType via WASM and TypeScript

This enables abstract-utxo to check network support for script types
without depending on utxo-lib.

Author: OttoAllmendinger

packages/wasm-utxo/js/fixedScriptWallet/index.ts

@@ -1,3 +1,6 @@
+import { FixedScriptWalletNamespace } from "../wasm/wasm_utxo.js";
+import type { CoinName } from "../coinName.js";
+
 export { RootWalletKeys, type WalletKeysArg, type IWalletKeys } from "./RootWalletKeys.js";
 export { ReplayProtection, type ReplayProtectionArg } from "./ReplayProtection.js";
 export { outputScript, address } from "./address.js";
@@ -26,3 +29,36 @@ export {
   type ZcashNetworkName,
   type CreateEmptyZcashOptions,
 } from "./ZcashBitGoPsbt.js";
+
+/**
+ * Fixed-script wallet script types (2-of-3 multisig)
+ *
+ * This type represents the abstract script type, independent of chain (external/internal).
+ * Use this for checking network support or when you need the script type without derivation info.
+ */
+export type ScriptType = "p2sh" | "p2shP2wsh" | "p2wsh" | "p2tr" | "p2trMusig2";
+
+/**
+ * Check if a network supports a given fixed-script wallet script type
+ *
+ * @param coin - Coin name (e.g., "btc", "ltc", "doge")
+ * @param scriptType - Script type to check
+ * @returns `true` if the network supports the script type, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * // Bitcoin supports all script types
+ * supportsScriptType("btc", "p2tr"); // true
+ *
+ * // Litecoin supports segwit but not taproot
+ * supportsScriptType("ltc", "p2wsh"); // true
+ * supportsScriptType("ltc", "p2tr"); // false
+ *
+ * // Dogecoin only supports legacy scripts
+ * supportsScriptType("doge", "p2sh"); // true
+ * supportsScriptType("doge", "p2wsh"); // false
+ * ```
+ */
+export function supportsScriptType(coin: CoinName, scriptType: ScriptType): boolean {
+  return FixedScriptWalletNamespace.supports_script_type(coin, scriptType);
+}

packages/wasm-utxo/src/address/networks.rs

@@ -13,6 +13,7 @@ use super::{
     ZCASH_TEST,
 };
 use crate::bitcoin::Script;
+use crate::fixed_script_wallet::wallet_scripts::ScriptType;
 use crate::networks::Network;
 use miniscript::bitcoin::WitnessVersion;
 
@@ -120,6 +121,15 @@ impl OutputScriptSupport {
         }
         Ok(())
     }
+
+    /// Check if the network supports a given fixed-script wallet script type
+    pub fn supports_script_type(&self, script_type: ScriptType) -> bool {
+        match script_type {
+            ScriptType::P2sh => true, // all networks support legacy scripts
+            ScriptType::P2shP2wsh | ScriptType::P2wsh => self.segwit,
+            ScriptType::P2tr | ScriptType::P2trMusig2 => self.taproot,
+        }
+    }
 }
 
 impl Network {

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

@@ -177,6 +177,69 @@ impl FromStr for Chain {
     }
 }
 
+/// Fixed-script wallet script types (2-of-3 multisig)
+///
+/// This enum represents the abstract script type, independent of chain (external/internal).
+/// Use this for checking network support or when you need the script type without derivation info.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum ScriptType {
+    /// Legacy Pay-To-Script-Hash (chains 0, 1)
+    P2sh,
+    /// Wrapped-Segwit Pay-To-Script-Hash (chains 10, 11)
+    P2shP2wsh,
+    /// Native Segwit Pay-To-Witness-Script-Hash (chains 20, 21)
+    P2wsh,
+    /// Legacy Taproot, script-path only (chains 30, 31)
+    P2tr,
+    /// Taproot with MuSig2 key-path support (chains 40, 41)
+    P2trMusig2,
+}
+
+impl ScriptType {
+    /// Parse a script type from a string
+    pub fn from_str(s: &str) -> Result<Self, String> {
+        match s {
+            "p2sh" => Ok(ScriptType::P2sh),
+            "p2shP2wsh" => Ok(ScriptType::P2shP2wsh),
+            "p2wsh" => Ok(ScriptType::P2wsh),
+            "p2tr" => Ok(ScriptType::P2tr),
+            "p2trMusig2" => Ok(ScriptType::P2trMusig2),
+            _ => Err(format!(
+                "Unknown script type '{}'. Expected: p2sh, p2shP2wsh, p2wsh, p2tr, p2trMusig2",
+                s
+            )),
+        }
+    }
+
+    /// Get the script type for a given chain
+    pub fn from_chain(chain: Chain) -> Self {
+        match chain {
+            Chain::P2shExternal | Chain::P2shInternal => ScriptType::P2sh,
+            Chain::P2shP2wshExternal | Chain::P2shP2wshInternal => ScriptType::P2shP2wsh,
+            Chain::P2wshExternal | Chain::P2wshInternal => ScriptType::P2wsh,
+            Chain::P2trInternal | Chain::P2trExternal => ScriptType::P2tr,
+            Chain::P2trMusig2Internal | Chain::P2trMusig2External => ScriptType::P2trMusig2,
+        }
+    }
+
+    /// Get the string representation of the script type
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ScriptType::P2sh => "p2sh",
+            ScriptType::P2shP2wsh => "p2shP2wsh",
+            ScriptType::P2wsh => "p2wsh",
+            ScriptType::P2tr => "p2tr",
+            ScriptType::P2trMusig2 => "p2trMusig2",
+        }
+    }
+}
+
+impl std::fmt::Display for ScriptType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
 /// Return derived WalletKeys. All keys are derived with the same path.
 #[allow(dead_code)]
 pub fn derive_xpubs_with_path(

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

@@ -8,6 +8,7 @@ use wasm_bindgen::JsValue;
 
 use crate::address::networks::AddressFormat;
 use crate::error::WasmUtxoError;
+use crate::fixed_script_wallet::wallet_scripts::ScriptType;
 use crate::fixed_script_wallet::{Chain, WalletScripts};
 use crate::utxolib_compat::UtxolibNetwork;
 use crate::wasm::bip32::WasmBIP32;
@@ -84,6 +85,27 @@ impl FixedScriptWalletNamespace {
         .map_err(|e| WasmUtxoError::new(&format!("Failed to generate address: {}", e)))?;
         Ok(address)
     }
+
+    /// Check if a network supports a given fixed-script wallet script type
+    ///
+    /// # Arguments
+    /// * `coin` - Coin name (e.g., "btc", "ltc", "doge")
+    /// * `script_type` - Script type name: "p2sh", "p2shP2wsh", "p2wsh", "p2tr", "p2trMusig2"
+    ///
+    /// # Returns
+    /// `true` if the network supports the script type, `false` otherwise
+    ///
+    /// # Examples
+    /// - Bitcoin supports all script types (p2sh, p2shP2wsh, p2wsh, p2tr, p2trMusig2)
+    /// - Litecoin supports segwit but not taproot (p2sh, p2shP2wsh, p2wsh)
+    /// - Dogecoin only supports legacy scripts (p2sh)
+    #[wasm_bindgen]
+    pub fn supports_script_type(coin: &str, script_type: &str) -> Result<bool, WasmUtxoError> {
+        let network = crate::networks::Network::from_coin_name(coin)
+            .ok_or_else(|| WasmUtxoError::new(&format!("Unknown coin: {}", coin)))?;
+        let st = ScriptType::from_str(script_type).map_err(|e| WasmUtxoError::new(&e))?;
+        Ok(network.output_script_support().supports_script_type(st))
+    }
 }
 #[wasm_bindgen]
 pub struct BitGoPsbt {