@utxopia/sdk 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/psbt.d.ts

@@ -9,6 +9,7 @@
  *
  * Uses @scure/btc-signer for PSBT construction.
  */
+import { type BitcoinNetwork } from "./taproot";
 /** UTXO descriptor for PSBT inputs */
 export interface UtxoDescriptor {
     /** Transaction ID (hex, 64 chars) */
@@ -31,13 +32,20 @@ export interface BuildDepositPsbtParams {
     /** Deposit amount in satoshis */
     depositAmountSats: number;
     /** Compact deposit OP_RETURN payload (from buildDepositOpReturn) */
-    opReturnPayload: Uint8Array;
+    /**
+     * 73-byte deposit metadata, for the OP_RETURN flow.
+     *
+     * Omit it for an OP_RETURN-free deposit (`verify_deposit`), where the address
+     * itself binds the note keys through its tapleaf. The transaction is then a
+     * plain payment, which is what lets an exchange withdrawal fund it.
+     */
+    opReturnPayload?: Uint8Array;
     /** Change address (same type as sender) */
     changeAddress: string;
     /** Fee rate in sats/vbyte */
     feeRate: number;
     /** Bitcoin network */
-    network?: "mainnet" | "testnet" | "signet";
+    network?: BitcoinNetwork;
 }
 /** Result of PSBT construction */
 export interface BuildDepositPsbtResult {
@@ -55,7 +63,10 @@ export interface BuildDepositPsbtResult {
 /**
  * Estimate the transaction fee for a deposit PSBT.
  */
-export declare function estimateDepositFee(numInputs: number, feeRate: number, inputType?: "p2tr" | "p2wpkh", hasChange?: boolean): number;
+export declare function estimateDepositFee(numInputs: number, feeRate: number, inputType?: "p2tr" | "p2wpkh", hasChange?: boolean, 
+/** An OP_RETURN-free deposit has one output fewer; defaults true for callers
+ *  written before that flow existed. */
+hasOpReturn?: boolean): number;
 /**
  * Build a deposit PSBT with OP_RETURN for non-interactive stealth deposits.
  *

package/dist/psbt.js

@@ -11,7 +11,7 @@
  */
 import * as btc from "@scure/btc-signer";
 import { hex } from "@scure/base";
-import { DEPOSIT_OP_RETURN_SIZE, createOpReturnScriptFromPayload } from "./taproot";
+import { DEPOSIT_OP_RETURN_SIZE, createOpReturnScriptFromPayload, bech32Hrp } from "./taproot";
 // =============================================================================
 // Constants
 // =============================================================================
@@ -33,13 +33,15 @@ const TX_OVERHEAD_VBYTES = 11;
 /**
  * Estimate the transaction fee for a deposit PSBT.
  */
-export function estimateDepositFee(numInputs, feeRate, inputType = "p2tr", hasChange = true) {
+export function estimateDepositFee(numInputs, feeRate, inputType = "p2tr", hasChange = true, 
+/** An OP_RETURN-free deposit has one output fewer; defaults true for callers
+ *  written before that flow existed. */
+hasOpReturn = true) {
     const inputVbytes = inputType === "p2tr" ? P2TR_INPUT_VBYTES : P2WPKH_INPUT_VBYTES;
-    const outputCount = hasChange ? 3 : 2; // deposit + OP_RETURN + optional change
     const vsize = TX_OVERHEAD_VBYTES +
         numInputs * inputVbytes +
         P2TR_OUTPUT_VBYTES + // deposit output
-        OP_RETURN_OUTPUT_VBYTES + // OP_RETURN output
+        (hasOpReturn ? OP_RETURN_OUTPUT_VBYTES : 0) +
         (hasChange ? P2TR_OUTPUT_VBYTES : 0); // change output
     return Math.ceil(vsize * feeRate);
 }
@@ -59,20 +61,24 @@ export function buildDepositPsbt(params) {
     if (depositAmountSats < DUST_LIMIT) {
         throw new Error(`Deposit amount ${depositAmountSats} is below dust limit ${DUST_LIMIT}`);
     }
-    if (opReturnPayload.length !== DEPOSIT_OP_RETURN_SIZE) {
+    if (opReturnPayload && opReturnPayload.length !== DEPOSIT_OP_RETURN_SIZE) {
         throw new Error(`OP_RETURN payload must be ${DEPOSIT_OP_RETURN_SIZE} bytes, got ${opReturnPayload.length}`);
     }
-    const btcNetwork = network === "mainnet" ? btc.NETWORK : btc.TEST_NETWORK;
+    // Regtest shares testnet's version bytes but not its bech32 hrp, so folding it
+    // into TEST_NETWORK leaves every bcrt1 address undecodable.
+    const btcNetwork = network === "mainnet"
+        ? btc.NETWORK
+        : { ...btc.TEST_NETWORK, bech32: bech32Hrp(network) };
     // Calculate total input value
     const totalInput = senderUtxos.reduce((sum, u) => sum + u.value, 0);
     // Detect input type from first UTXO
     const firstScript = hex.decode(senderUtxos[0].scriptPubkeyHex);
     const inputType = firstScript[0] === 0x51 ? "p2tr" : "p2wpkh";
     // Estimate fee with change
-    const feeWithChange = estimateDepositFee(senderUtxos.length, feeRate, inputType, true);
+    const feeWithChange = estimateDepositFee(senderUtxos.length, feeRate, inputType, true, Boolean(opReturnPayload));
     const changeAmount = totalInput - depositAmountSats - feeWithChange;
     // Check if we have enough funds
-    const feeWithoutChange = estimateDepositFee(senderUtxos.length, feeRate, inputType, false);
+    const feeWithoutChange = estimateDepositFee(senderUtxos.length, feeRate, inputType, false, Boolean(opReturnPayload));
     if (totalInput < depositAmountSats + feeWithoutChange) {
         throw new Error(`Insufficient funds: have ${totalInput} sats, need ${depositAmountSats + feeWithoutChange} sats (including fee)`);
     }
@@ -113,12 +119,15 @@ export function buildDepositPsbt(params) {
     }
     // Output 1: P2TR deposit
     tx.addOutputAddress(depositAddress, BigInt(depositAmountSats), btcNetwork);
-    // Output 2: OP_RETURN with compact deposit payload.
-    const opReturnScript = createOpReturnScriptFromPayload(opReturnPayload);
-    tx.addOutput({
-        script: opReturnScript,
-        amount: 0n,
-    });
+    // Output 2: OP_RETURN with compact deposit payload — only for that flow. A
+    // tweak-bound deposit adds nothing here, so the transaction is indistinguishable
+    // from an ordinary payment.
+    if (opReturnPayload) {
+        tx.addOutput({
+            script: createOpReturnScriptFromPayload(opReturnPayload),
+            amount: 0n,
+        });
+    }
     // Output 3: Change (if above dust)
     if (hasChange) {
         tx.addOutputAddress(changeAddress, BigInt(changeAmount), btcNetwork);

package/dist/spend-doc.js

@@ -11,6 +11,7 @@
  * Poseidon(merkleRoot, boundParamsHash, nullifiers.., commitmentsOut..).
  */
 import { computeSolanaDomainBoundParamsHash, createRedeemBoundParams, createTransferBoundParams, createUnshieldBoundParams, } from "./bound-params";
+import { bytesToHex as hex } from "./crypto";
 export class SpendDocMismatch extends Error {
 }
 function fmt(raw, decimals) {
@@ -20,7 +21,6 @@ function fmt(raw, decimals) {
     const frac = decimals === 0 ? "" : s.slice(s.length - decimals).replace(/0+$/, "");
     return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
 }
-const hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
 function sortedValues(v) {
     return [...v].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)).join(",");
 }

package/dist/stealth.d.ts

@@ -189,8 +189,8 @@ export interface NonInteractiveDepositWithRefundResult extends NonInteractiveDep
  * @param network - Bitcoin network for address encoding
  * @param userRefundPubkey - Optional 32-byte x-only pubkey for refund script path
  */
-export declare function createNonInteractiveDeposit(recipientMeta: StealthMetaAddress, custodyInternalKey: Uint8Array, network?: "mainnet" | "testnet" | "regtest", userRefundPubkey?: undefined, opReturnContext?: DepositOpReturnContext): Promise<NonInteractiveDepositResult>;
-export declare function createNonInteractiveDeposit(recipientMeta: StealthMetaAddress, custodyInternalKey: Uint8Array, network: "mainnet" | "testnet" | "regtest", userRefundPubkey: Uint8Array, opReturnContext: DepositOpReturnContext): Promise<NonInteractiveDepositWithRefundResult>;
+export declare function createNonInteractiveDeposit(recipientMeta: StealthMetaAddress, custodyInternalKey: Uint8Array, network?: BitcoinNetwork, userRefundPubkey?: undefined, opReturnContext?: DepositOpReturnContext): Promise<NonInteractiveDepositResult>;
+export declare function createNonInteractiveDeposit(recipientMeta: StealthMetaAddress, custodyInternalKey: Uint8Array, network: BitcoinNetwork, userRefundPubkey: Uint8Array, opReturnContext: DepositOpReturnContext): Promise<NonInteractiveDepositWithRefundResult>;
 /**
  * Create a non-interactive deposit directly to an Ika-controlled vault.
  *
@@ -199,7 +199,7 @@ export declare function createNonInteractiveDeposit(recipientMeta: StealthMetaAd
  * in OP_RETURN(header || poolTag || ephemeralPub || npk), and the destination chain
  * credits the note from that transaction.
  */
-export declare function createDirectVaultDeposit(recipientMeta: StealthMetaAddress, vaultXOnlyPubkey: Uint8Array, network?: "mainnet" | "testnet" | "regtest", opReturnContext?: DepositOpReturnContext): Promise<NonInteractiveDepositResult>;
+export declare function createDirectVaultDeposit(recipientMeta: StealthMetaAddress, vaultXOnlyPubkey: Uint8Array, network?: BitcoinNetwork, opReturnContext?: DepositOpReturnContext): Promise<NonInteractiveDepositResult>;
 /**
  * The delegable half of deposit recovery.
  *
@@ -322,7 +322,7 @@ export interface TweakDepositResult {
  * with no OP_RETURN is invisible to block scanning, so an unregistered address
  * is one nobody is watching.
  */
-export declare function createTweakDeposit(recipientMeta: StealthMetaAddress, vaultXOnlyPubkey: Uint8Array, recovery: DepositRecoveryMaterial, network?: "mainnet" | "testnet" | "regtest"): Promise<TweakDepositResult>;
+export declare function createTweakDeposit(recipientMeta: StealthMetaAddress, vaultXOnlyPubkey: Uint8Array, recovery: DepositRecoveryMaterial, network?: BitcoinNetwork): Promise<TweakDepositResult>;
 /**
  * Create a non-interactive deposit using the current SDK config.
  *
@@ -333,7 +333,7 @@ export declare function createTweakDeposit(recipientMeta: StealthMetaAddress, va
  * credits the note by SPV-verifying that deposit transaction directly. Legacy sweep-mode
  * address derivation is intentionally not selected from config anymore.
  */
-export declare function createDepositFromConfig(recipientMeta: StealthMetaAddress, network?: "mainnet" | "testnet" | "regtest", opReturnContext?: DepositOpReturnContext): Promise<NonInteractiveDepositResult>;
+export declare function createDepositFromConfig(recipientMeta: StealthMetaAddress, network?: BitcoinNetwork, opReturnContext?: DepositOpReturnContext): Promise<NonInteractiveDepositResult>;
 export declare function isDirectVaultDepositMode(mode?: string): boolean;
 /**
  * Choose the Taproot internal key for deposit-address derivation.
@@ -448,6 +448,7 @@ export declare function scanUnifiedNotesMulti(source: WalletSignerAdapter | UTXO
  */
 export declare function scanUnifiedNotes(source: WalletSignerAdapter | UTXOpiaKeys, announcements: OnChainStealthAnnouncement[], tokenId: bigint): Promise<ScannedNote[]>;
 import type { Address } from "@solana/kit";
+import type { BitcoinNetwork } from "./taproot";
 export interface ConnectionAdapter {
     getAccountInfo: (pubkey: Address) => Promise<{
         data: Uint8Array;
@@ -480,13 +481,6 @@ export declare function packEncryptedAmountWithSign(encryptedAmount: Uint8Array,
  * Convert StealthOutputData to circuit-ready format
  */
 export declare function packStealthOutputForCircuit(output: StealthOutputData): CircuitStealthOutput;
-/**
- * Unpack encrypted amount from packed Field element
- */
-export declare function unpackEncryptedAmountWithSign(packed: bigint): {
-    encryptedAmount: Uint8Array;
-    ySign: boolean;
-};
 /**
  * Create stealth output data for a self-send (change output)
  */

package/dist/stealth.js

@@ -737,20 +737,6 @@ export function packStealthOutputForCircuit(output) {
         encryptedAmountWithSign,
     };
 }
-/**
- * Unpack encrypted amount from packed Field element
- */
-export function unpackEncryptedAmountWithSign(packed) {
-    const ySign = (packed & (1n << 64n)) !== 0n;
-    const amount = packed & ((1n << 64n) - 1n);
-    const encryptedAmount = new Uint8Array(8);
-    let temp = amount;
-    for (let i = 0; i < 8; i++) {
-        encryptedAmount[i] = Number(temp & 0xffn);
-        temp >>= 8n;
-    }
-    return { encryptedAmount, ySign };
-}
 /**
  * Create stealth output data for a self-send (change output)
  */

package/dist/taproot.d.ts

@@ -18,7 +18,7 @@
  * @param internalKey - Configured FROST/Ika custody key (x-only, 32 bytes; required)
  * @returns Taproot address (bc1p... or tb1p...)
  */
-export declare function deriveTaprootAddress(commitment: Uint8Array, network?: "mainnet" | "testnet" | "regtest", internalKey?: Uint8Array): {
+export declare function deriveTaprootAddress(commitment: Uint8Array, network?: BitcoinNetwork, internalKey?: Uint8Array): {
     address: string;
     outputKey: Uint8Array;
     tweak: Uint8Array;
@@ -64,7 +64,7 @@ export declare function depositLeafScript(commitment: Uint8Array, ikaXOnlyPubkey
  * Returns everything the sweeper needs to spend it: a script-path witness is
  * `[signature, leafScript, controlBlock]`.
  */
-export declare function deriveDepositAddress(commitment: Uint8Array, ikaXOnlyPubkey: Uint8Array, network?: "mainnet" | "testnet" | "regtest"): {
+export declare function deriveDepositAddress(commitment: Uint8Array, ikaXOnlyPubkey: Uint8Array, network?: BitcoinNetwork): {
     address: string;
     outputKey: Uint8Array;
     leafScript: Uint8Array;
@@ -80,6 +80,34 @@ export declare function deriveDepositAddress(commitment: Uint8Array, ikaXOnlyPub
  * @returns true if address matches expected derivation
  */
 export declare function verifyTaprootAddress(address: string, commitment: Uint8Array, internalKey?: Uint8Array): boolean;
+/**
+ * The networks whose addresses this SDK derives.
+ *
+ * Kept as one alias because the members drifted when it was spelled out at each
+ * call site: psbt.ts folded regtest into testnet while taproot.ts did not, and
+ * the two disagreed about what a bcrt1 address was.
+ */
+export type BitcoinNetwork = "mainnet" | "testnet" | "signet" | "regtest";
+/**
+ * bech32 human-readable prefix for a Bitcoin network.
+ *
+ * Regtest is the reason this exists: it shares testnet's version bytes but not
+ * its prefix, and every place that folded the two together produced addresses
+ * no regtest node would accept.
+ */
+export declare function bech32Hrp(network: BitcoinNetwork): string;
+/**
+ * The network an address's bech32 prefix names, or null if it names none.
+ *
+ * Null rather than a testnet default: an unrecognised prefix is an address this
+ * SDK cannot place, and quietly calling it testnet is how bcrt1 addresses ended
+ * up classified as testnet everywhere.
+ */
+export declare function networkForHrp(prefix: string): BitcoinNetwork | null;
+/**
+ * Encode an x-only output key as a witness-v1 (P2TR) address.
+ */
+export declare function p2trAddress(outputKey: Uint8Array, network: BitcoinNetwork): string;
 /**
  * Generate a P2TR (Pay-to-Taproot) script pubkey
  *
@@ -100,7 +128,7 @@ export declare function parseP2TRScriptPubkey(scriptPubkey: Uint8Array): Uint8Ar
 export declare function isValidBitcoinAddress(address: string): {
     valid: boolean;
     type: "p2pkh" | "p2sh" | "p2wpkh" | "p2wsh" | "p2tr" | "unknown";
-    network: "mainnet" | "testnet" | "unknown";
+    network: BitcoinNetwork | "unknown";
 };
 /** Destination chain encoded in the compact deposit OP_RETURN header. */
 export declare const DEPOSIT_DESTINATION_CHAIN: {
@@ -201,7 +229,7 @@ export declare function computeTapLeafHash(script: Uint8Array, leafVersion?: num
  * @param internalKey - 32-byte x-only FROST group public key
  * @param network - Bitcoin network for address encoding
  */
-export declare function deriveTaprootAddressWithRefund(npk: Uint8Array, userRefundPubkey: Uint8Array, internalKey: Uint8Array, network?: "mainnet" | "testnet" | "regtest"): {
+export declare function deriveTaprootAddressWithRefund(npk: Uint8Array, userRefundPubkey: Uint8Array, internalKey: Uint8Array, network?: BitcoinNetwork): {
     address: string;
     outputKey: Uint8Array;
     merkleRoot: Uint8Array;

package/dist/taproot.js

@@ -7,7 +7,7 @@
  */
 import { sha256 } from "@noble/hashes/sha2.js";
 import { taggedHash, hexToBytes, bytesToHex } from "./crypto";
-import * as bech32 from "bech32";
+import { bech32, bech32m } from "@scure/base";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 // Never use the secp256k1 generator as a custody key. Its discrete log is
 // public, so a key-path output derived from it is sweepable by anyone.
@@ -59,11 +59,7 @@ export function deriveTaprootAddress(commitment, network = "testnet", internalKe
     // x-only output key (BIP-340): drop prefix from compressed form
     const outputKeyHex = outputPoint.toHex(true); // 33-byte compressed hex
     const outputKey = hexToBytes(outputKeyHex.slice(2)); // drop "02"/"03" prefix
-    // Encode as bech32m address
-    const hrp = network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
-    const words = bech32.bech32m.toWords(outputKey);
-    // Witness version 1 for taproot
-    const address = bech32.bech32m.encode(hrp, [1, ...words]);
+    const address = p2trAddress(outputKey, network);
     return {
         address,
         outputKey,
@@ -151,20 +147,56 @@ export function deriveDepositAddress(commitment, ikaXOnlyPubkey, network = "test
  */
 export function verifyTaprootAddress(address, commitment, internalKey) {
     try {
-        const decoded = bech32.bech32m.decode(address);
+        const decoded = bech32m.decode(address);
         const witnessVersion = decoded.words[0];
         if (witnessVersion !== 1) {
             return false;
         }
-        const actualOutputKey = new Uint8Array(bech32.bech32m.fromWords(decoded.words.slice(1)));
-        const network = decoded.prefix === "bc" ? "mainnet" : "testnet";
+        const network = networkForHrp(decoded.prefix);
+        if (!network)
+            return false;
         const expected = deriveTaprootAddress(commitment, network, internalKey);
-        return arraysEqual(actualOutputKey, expected.outputKey);
+        // Compare the whole address, not just the output key: the key is identical
+        // on every network, so an output-key match said nothing about the encoding.
+        // bech32 is case-insensitive, hence the fold.
+        return address.toLowerCase() === expected.address;
     }
     catch {
         return false;
     }
 }
+/**
+ * bech32 human-readable prefix for a Bitcoin network.
+ *
+ * Regtest is the reason this exists: it shares testnet's version bytes but not
+ * its prefix, and every place that folded the two together produced addresses
+ * no regtest node would accept.
+ */
+export function bech32Hrp(network) {
+    return network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
+}
+/**
+ * The network an address's bech32 prefix names, or null if it names none.
+ *
+ * Null rather than a testnet default: an unrecognised prefix is an address this
+ * SDK cannot place, and quietly calling it testnet is how bcrt1 addresses ended
+ * up classified as testnet everywhere.
+ */
+export function networkForHrp(prefix) {
+    return prefix === "bc"
+        ? "mainnet"
+        : prefix === "tb"
+            ? "testnet"
+            : prefix === "bcrt"
+                ? "regtest"
+                : null;
+}
+/**
+ * Encode an x-only output key as a witness-v1 (P2TR) address.
+ */
+export function p2trAddress(outputKey, network) {
+    return bech32m.encode(bech32Hrp(network), [1, ...bech32m.toWords(outputKey)]);
+}
 /**
  * Generate a P2TR (Pay-to-Taproot) script pubkey
  *
@@ -203,32 +235,24 @@ export function parseP2TRScriptPubkey(scriptPubkey) {
 export function isValidBitcoinAddress(address) {
     try {
         // Bech32m (Taproot)
-        if (address.startsWith("bc1p") || address.startsWith("tb1p")) {
-            const decoded = bech32.bech32m.decode(address);
-            if (decoded.words[0] === 1 && decoded.words.length === 53) {
-                return {
-                    valid: true,
-                    type: "p2tr",
-                    network: decoded.prefix === "bc" ? "mainnet" : "testnet",
-                };
+        if (address.startsWith("bc1p") ||
+            address.startsWith("tb1p") ||
+            address.startsWith("bcrt1p")) {
+            const decoded = bech32m.decode(address);
+            const network = networkForHrp(decoded.prefix);
+            if (network && decoded.words[0] === 1 && decoded.words.length === 53) {
+                return { valid: true, type: "p2tr", network };
             }
         }
         // Bech32 (SegWit v0)
         if (address.startsWith("bc1q") ||
             address.startsWith("tb1q") ||
             address.startsWith("bcrt1q")) {
-            const decoded = bech32.bech32.decode(address);
-            if (decoded.words[0] === 0) {
+            const decoded = bech32.decode(address);
+            const network = networkForHrp(decoded.prefix);
+            if (network && decoded.words[0] === 0) {
                 const type = decoded.words.length === 33 ? "p2wpkh" : "p2wsh";
-                return {
-                    valid: true,
-                    type,
-                    network: decoded.prefix === "bc"
-                        ? "mainnet"
-                        : decoded.prefix === "bcrt"
-                            ? "testnet"
-                            : "testnet",
-                };
+                return { valid: true, type, network };
             }
         }
         // Legacy (base58check)
@@ -533,9 +557,7 @@ export function deriveTaprootAddressWithRefund(npk, userRefundPubkey, internalKe
     controlBlock[0] = 0xc0 | parityBit;
     controlBlock.set(internalKey, 1);
     // 7. Encode as bech32m address
-    const hrp = network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
-    const words = bech32.bech32m.toWords(outputKey);
-    const address = bech32.bech32m.encode(hrp, [1, ...words]);
+    const address = p2trAddress(outputKey, network);
     return {
         address,
         outputKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utxopia/sdk",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "description": "UTXOpia SDK - Private Bitcoin across Solana and Sui",
   "type": "module",
   "main": "dist/index.js",
@@ -27,40 +27,10 @@
       "import": "./dist/prover/mobile.js",
       "default": "./dist/prover/mobile.js"
     },
-    "./stealth": {
-      "types": "./dist/stealth/index.d.ts",
-      "import": "./dist/stealth/index.js",
-      "default": "./dist/stealth/index.js"
-    },
     "./bitcoin": {
       "types": "./dist/bitcoin/index.d.ts",
       "import": "./dist/bitcoin/index.js",
       "default": "./dist/bitcoin/index.js"
-    },
-    "./solana": {
-      "types": "./dist/solana/index.d.ts",
-      "import": "./dist/solana/index.js",
-      "default": "./dist/solana/index.js"
-    },
-    "./watcher": {
-      "types": "./dist/watcher/index.d.ts",
-      "import": "./dist/watcher/index.js",
-      "default": "./dist/watcher/index.js"
-    },
-    "./watcher/web": {
-      "types": "./dist/watcher/web.d.ts",
-      "import": "./dist/watcher/web.js",
-      "default": "./dist/watcher/web.js"
-    },
-    "./watcher/native": {
-      "types": "./dist/watcher/native.d.ts",
-      "import": "./dist/watcher/native.js",
-      "default": "./dist/watcher/native.js"
-    },
-    "./react": {
-      "types": "./dist/react/index.d.ts",
-      "import": "./dist/react/index.js",
-      "default": "./dist/react/index.js"
     }
   },
   "files": [
@@ -93,7 +63,6 @@
     "@scure/btc-signer": "2.0.1",
     "@solana-program/system": "^0.10.0",
     "@solana/kit": "^5.5.0",
-    "bech32": "^2.0.0",
     "circomlibjs": "^0.1.7",
     "poseidon-lite": "0.3.0"
   },

package/src/bitcoin/ika.ts

@@ -8,7 +8,7 @@
  */
 
 import { taggedHash, hexToBytes, bytesToHex } from "../crypto";
-import { bech32m } from "bech32";
+import { p2trAddress, type BitcoinNetwork } from "../taproot";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 
 /**
@@ -33,12 +33,12 @@ export type IkaDWalletRef =
  *   address = bech32m(hrp, [witness_version=1, ...words(output_key)])
  *
  * @param ref       The Ika dWallet reference (literal pubkey, or future async id).
- * @param network   "mainnet" | "testnet" | "regtest"
+ * @param network   BitcoinNetwork
  * @returns         The P2TR address (`bc1p…` / `tb1p…` / `bcrt1p…`)
  */
 export function deriveCustodyAddressFromIkaDWallet(
   ref: IkaDWalletRef,
-  network: "mainnet" | "testnet" | "regtest"
+  network: BitcoinNetwork
 ): string {
   const xonly = extractXOnly(ref);
   const tweak = taggedHash("TapTweak", xonly);
@@ -52,10 +52,7 @@ export function deriveCustodyAddressFromIkaDWallet(
   // Drop the 1-byte parity prefix to get the x-only output key.
   const outputKey = hexToBytes(outputPoint.toHex(true).slice(2));
 
-  const hrp =
-    network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
-  const words = bech32m.toWords(outputKey);
-  return bech32m.encode(hrp, [1, ...words]);
+  return p2trAddress(outputKey, network);
 }
 
 /**
@@ -67,14 +64,12 @@ export function deriveCustodyAddressFromIkaDWallet(
  */
 export function deriveRawXOnlyP2TRAddress(
   xonlyPubkey: Uint8Array,
-  network: "mainnet" | "testnet" | "regtest"
+  network: BitcoinNetwork
 ): string {
   if (xonlyPubkey.length !== 32) {
     throw new Error("xonlyPubkey must be 32 bytes");
   }
-  const hrp =
-    network === "mainnet" ? "bc" : network === "regtest" ? "bcrt" : "tb";
-  return bech32m.encode(hrp, [1, ...bech32m.toWords(xonlyPubkey)]);
+  return p2trAddress(xonlyPubkey, network);
 }
 
 function extractXOnly(ref: IkaDWalletRef): Uint8Array {

package/src/client.ts

@@ -56,7 +56,7 @@ import {
 import { selectUtxos, type UtxoDescriptor } from "./psbt";
 import { hexToBytes, bytesToHex, bigintToBytes } from "./crypto";
 import { EventClient } from "./event-client";
-import { type DepositOpReturnContext } from "./taproot";
+import { type DepositOpReturnContext, type BitcoinNetwork } from "./taproot";
 
 // ─── Types ──────────────────────────────────────────────────────────
 
@@ -425,7 +425,7 @@ export class UTXOpiaClient {
     depositIndex: number;
     ikaXOnlyPubkey: Uint8Array;
     recipient?: StealthMetaAddress;
-    network?: "mainnet" | "testnet" | "regtest";
+    network?: BitcoinNetwork;
   }): Promise<TweakDepositResult> {
     if (!this._keys) {
       throw new Error("No keys (login first)");
@@ -457,7 +457,7 @@ export class UTXOpiaClient {
    */
   async prepareDeposit(opts: {
     recipient?: StealthMetaAddress;
-    network?: "mainnet" | "testnet" | "regtest";
+    network?: BitcoinNetwork;
     opReturnContext: DepositOpReturnContext;
   }): Promise<NonInteractiveDepositResult> {
     const meta = opts.recipient ?? this._stealthAddress;
@@ -631,7 +631,7 @@ export class UTXOpiaClient {
   }
 }
 
-function sdkBitcoinNetworkToAddressNetwork(network: NetworkConfig["bitcoinNetwork"]): "mainnet" | "testnet" | "regtest" {
+function sdkBitcoinNetworkToAddressNetwork(network: NetworkConfig["bitcoinNetwork"]): BitcoinNetwork {
   if (network === "mainnet") return "mainnet";
   if (network === "regtest") return "regtest";
   return "testnet";

package/src/crypto-babyjub.ts

@@ -35,11 +35,6 @@ export const BABYJUB_D = 168696n;
 export const BABYJUB_ORDER =
   2736030358979909402780800718157159386076813972158567259200215660948447373041n;
 
-/**
- * Baby Jubjub cofactor
- */
-export const BABYJUB_COFACTOR = 8n;
-
 /**
  * Generator point (BASE8) - matches circomlib's BabyPbk() generator
  * This is the base point of the prime-order subgroup (cofactor-cleared).

package/src/crypto.ts

@@ -14,6 +14,7 @@
  */
 
 import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex as nobleBytesToHex, hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
 
 // =============================================================================
 // Field Constants
@@ -110,22 +111,15 @@ export function bytesToBigint(bytes: Uint8Array): bigint {
  * Convert hex string to Uint8Array
  */
 export function hexToBytes(hex: string): Uint8Array {
-  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(cleanHex.length / 2);
-  for (let i = 0; i < cleanHex.length; i += 2) {
-    bytes[i / 2] = parseInt(cleanHex.substr(i, 2), 16);
-  }
-  return bytes;
+  // The 0x prefix is ours; noble rejects it. Everything after is noble's, which
+  // also means malformed hex now throws instead of decoding to zero bytes.
+  return nobleHexToBytes(hex.startsWith("0x") ? hex.slice(2) : hex);
 }
 
 /**
  * Convert Uint8Array to hex string
  */
-export function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes)
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-}
+export const bytesToHex = nobleBytesToHex;
 
 // =============================================================================
 // Hashing Utilities
@@ -184,16 +178,3 @@ export function scalarFromBytes(bytes: Uint8Array): bigint {
   }
   return mod(result, BABYJUB_ORDER);
 }
-
-/**
- * Convert a bigint scalar to 32 bytes (big-endian)
- */
-export function scalarToBytes(scalar: bigint): Uint8Array {
-  const bytes = new Uint8Array(32);
-  let temp = mod(scalar, BABYJUB_ORDER);
-  for (let i = 31; i >= 0; i--) {
-    bytes[i] = Number(temp & 0xffn);
-    temp = temp >> 8n;
-  }
-  return bytes;
-}

package/src/index.ts

@@ -349,6 +349,10 @@ export {
   DEPOSIT_OP_RETURN_VERSION,
   DEPOSIT_POOL_TAG_SIZE,
   DEPOSIT_OP_RETURN_SIZE,
+  bech32Hrp,
+  networkForHrp,
+  p2trAddress,
+  type BitcoinNetwork,
   type DepositDestinationChain,
   type DepositBitcoinNetwork,
   type DepositOpReturnContext,