@bitgo/wasm-utxo 1.6.0 → 1.8.0

package/dist/esm/js/wasm/wasm_utxo_bg.wasm.d.ts

@@ -1,28 +1,83 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
+export const __wbg_wasmreplayprotection_free: (a: number, b: number) => void;
+export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
+export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wasmreplayprotection_from_addresses: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmreplayprotection_from_output_scripts: (a: number, b: number) => number;
+export const wasmreplayprotection_from_public_keys: (a: number, b: number, c: number) => void;
+export const wrapminiscript_encode: (a: number, b: number) => void;
+export const wrapminiscript_fromBitcoinScript: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapminiscript_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wrapminiscript_node: (a: number, b: number) => void;
+export const wrapminiscript_toAsmString: (a: number, b: number) => void;
+export const wrapminiscript_toString: (a: number, b: number) => void;
 export const __wbg_addressnamespace_free: (a: number, b: number) => void;
-export const __wbg_bitgopsbt_free: (a: number, b: number) => void;
-export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
+export const __wbg_wasmbip32_free: (a: number, b: number) => void;
+export const __wbg_wasmecpair_free: (a: number, b: number) => void;
+export const __wbg_wasmrootwalletkeys_free: (a: number, b: number) => void;
 export const addressnamespace_from_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const addressnamespace_to_output_script_with_coin: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmbip32_chain_code: (a: number) => number;
+export const wasmbip32_depth: (a: number) => number;
+export const wasmbip32_derive: (a: number, b: number, c: number) => void;
+export const wasmbip32_derive_hardened: (a: number, b: number, c: number) => void;
+export const wasmbip32_derive_path: (a: number, b: number, c: number, d: number) => void;
+export const wasmbip32_fingerprint: (a: number) => number;
+export const wasmbip32_from_base58: (a: number, b: number, c: number) => void;
+export const wasmbip32_from_bip32_interface: (a: number, b: number) => void;
+export const wasmbip32_from_seed: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmbip32_from_xprv: (a: number, b: number, c: number) => void;
+export const wasmbip32_from_xpub: (a: number, b: number, c: number) => void;
+export const wasmbip32_identifier: (a: number) => number;
+export const wasmbip32_index: (a: number) => number;
+export const wasmbip32_is_neutered: (a: number) => number;
+export const wasmbip32_neutered: (a: number) => number;
+export const wasmbip32_parent_fingerprint: (a: number) => number;
+export const wasmbip32_private_key: (a: number) => number;
+export const wasmbip32_public_key: (a: number) => number;
+export const wasmbip32_to_base58: (a: number, b: number) => void;
+export const wasmbip32_to_wif: (a: number, b: number) => void;
+export const wasmecpair_from_private_key: (a: number, b: number, c: number) => void;
+export const wasmecpair_from_public_key: (a: number, b: number, c: number) => void;
+export const wasmecpair_from_wif: (a: number, b: number, c: number) => void;
+export const wasmecpair_from_wif_mainnet: (a: number, b: number, c: number) => void;
+export const wasmecpair_from_wif_testnet: (a: number, b: number, c: number) => void;
+export const wasmecpair_private_key: (a: number) => number;
+export const wasmecpair_public_key: (a: number) => number;
+export const wasmecpair_to_wif: (a: number, b: number) => void;
+export const wasmecpair_to_wif_mainnet: (a: number, b: number) => void;
+export const wasmecpair_to_wif_testnet: (a: number, b: number) => void;
+export const wasmrootwalletkeys_backup_key: (a: number) => number;
+export const wasmrootwalletkeys_bitgo_key: (a: number) => number;
+export const wasmrootwalletkeys_new: (a: number, b: number, c: number, d: number) => void;
+export const wasmrootwalletkeys_user_key: (a: number) => number;
+export const wasmrootwalletkeys_with_derivation_prefixes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+export const wasmbip32_from_bip32_properties: (a: number, b: number) => void;
+export const __wbg_bitgopsbt_free: (a: number, b: number) => void;
+export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
+export const __wbg_wrapdescriptor_free: (a: number, b: number) => void;
+export const __wbg_wrappsbt_free: (a: number, b: number) => void;
+export const bitgopsbt_combine_musig2_nonces: (a: number, b: number, c: number) => void;
 export const bitgopsbt_extract_transaction: (a: number, b: number) => void;
 export const bitgopsbt_finalize_all_inputs: (a: number, b: number) => void;
 export const bitgopsbt_from_bytes: (a: number, b: number, c: number, d: number, e: number) => void;
+export const bitgopsbt_generate_musig2_nonces: (a: number, b: number, c: number, d: number, e: number) => void;
+export const bitgopsbt_network: (a: number, b: number) => void;
 export const bitgopsbt_parse_outputs_with_wallet_keys: (a: number, b: number, c: number) => void;
 export const bitgopsbt_parse_transaction_with_wallet_keys: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_serialize: (a: number, b: number) => void;
+export const bitgopsbt_sign_with_privkey: (a: number, b: number, c: number, d: number) => void;
+export const bitgopsbt_sign_with_xpriv: (a: number, b: number, c: number, d: number) => void;
 export const bitgopsbt_unsigned_txid: (a: number, b: number) => void;
 export const bitgopsbt_verify_replay_protection_signature: (a: number, b: number, c: number, d: number) => void;
-export const bitgopsbt_verify_signature: (a: number, b: number, c: number, d: number, e: number) => void;
+export const bitgopsbt_verify_signature_with_pub: (a: number, b: number, c: number, d: number) => void;
+export const bitgopsbt_verify_signature_with_xpub: (a: number, b: number, c: number, d: number) => void;
 export const fixedscriptwalletnamespace_address: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const fixedscriptwalletnamespace_output_script: (a: number, b: number, c: number, d: number, e: number) => void;
-export const __wbg_utxolibcompatnamespace_free: (a: number, b: number) => void;
-export const __wbg_wrapdescriptor_free: (a: number, b: number) => void;
-export const __wbg_wrapminiscript_free: (a: number, b: number) => void;
-export const __wbg_wrappsbt_free: (a: number, b: number) => void;
-export const utxolibcompatnamespace_from_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const utxolibcompatnamespace_to_output_script: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const wrapdescriptor_atDerivationIndex: (a: number, b: number, c: number) => void;
 export const wrapdescriptor_descType: (a: number, b: number) => void;
 export const wrapdescriptor_encode: (a: number, b: number) => void;
@@ -34,12 +89,6 @@ export const wrapdescriptor_node: (a: number, b: number) => void;
 export const wrapdescriptor_scriptPubkey: (a: number, b: number) => void;
 export const wrapdescriptor_toAsmString: (a: number, b: number) => void;
 export const wrapdescriptor_toString: (a: number, b: number) => void;
-export const wrapminiscript_encode: (a: number, b: number) => void;
-export const wrapminiscript_fromBitcoinScript: (a: number, b: number, c: number, d: number, e: number) => void;
-export const wrapminiscript_fromString: (a: number, b: number, c: number, d: number, e: number) => void;
-export const wrapminiscript_node: (a: number, b: number) => void;
-export const wrapminiscript_toAsmString: (a: number, b: number) => void;
-export const wrapminiscript_toString: (a: number, b: number) => void;
 export const wrappsbt_clone: (a: number) => number;
 export const wrappsbt_deserialize: (a: number, b: number, c: number) => void;
 export const wrappsbt_finalize: (a: number, b: number) => void;

package/dist/esm/test/bip32.js

@@ -0,0 +1,242 @@
+import * as assert from "assert";
+import { bip32 as utxolibBip32 } from "@bitgo/utxo-lib";
+import { BIP32 } from "../js/bip32.js";
+const bip32 = { BIP32 };
+describe("WasmBIP32", () => {
+    it("should create from base58 xpub", () => {
+        const xpub = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5";
+        const key = bip32.BIP32.fromBase58(xpub);
+        assert.strictEqual(key.isNeutered(), true);
+        assert.strictEqual(key.depth, 3);
+        assert.strictEqual(key.toBase58(), xpub);
+        // Verify properties exist
+        assert.ok(key.chainCode instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+        assert.ok(key.identifier instanceof Uint8Array);
+        assert.ok(key.fingerprint instanceof Uint8Array);
+        assert.strictEqual(key.privateKey, undefined);
+    });
+    it("should create from base58 xprv", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const key = bip32.BIP32.fromBase58(xprv);
+        assert.strictEqual(key.isNeutered(), false);
+        assert.strictEqual(key.depth, 0);
+        assert.strictEqual(key.toBase58(), xprv);
+        // Verify properties exist
+        assert.ok(key.chainCode instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+        assert.ok(key.privateKey instanceof Uint8Array);
+        assert.ok(key.identifier instanceof Uint8Array);
+        assert.ok(key.fingerprint instanceof Uint8Array);
+    });
+    it("should derive child keys", () => {
+        const xpub = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5";
+        const key = bip32.BIP32.fromBase58(xpub);
+        const child = key.derive(0);
+        assert.strictEqual(child.depth, 4);
+        assert.strictEqual(child.isNeutered(), true);
+    });
+    it("should derive using path", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const key = bip32.BIP32.fromBase58(xprv);
+        const derived1 = key.derivePath("0/1/2");
+        assert.strictEqual(derived1.depth, 3);
+        const derived2 = key.derivePath("m/0/1/2");
+        assert.strictEqual(derived2.depth, 3);
+        // Both should produce the same result
+        assert.strictEqual(derived1.toBase58(), derived2.toBase58());
+    });
+    it("should neutered a private key", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const key = bip32.BIP32.fromBase58(xprv);
+        const neuteredKey = key.neutered();
+        assert.strictEqual(neuteredKey.isNeutered(), true);
+        assert.strictEqual(neuteredKey.privateKey, undefined);
+        assert.ok(neuteredKey.publicKey instanceof Uint8Array);
+    });
+    it("should derive hardened keys from private key", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const key = bip32.BIP32.fromBase58(xprv);
+        const hardened = key.deriveHardened(0);
+        assert.strictEqual(hardened.depth, 1);
+        assert.strictEqual(hardened.isNeutered(), false);
+    });
+    it("should fail to derive hardened from public key", () => {
+        const xpub = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5";
+        const key = bip32.BIP32.fromBase58(xpub);
+        assert.throws(() => {
+            key.deriveHardened(0);
+        });
+    });
+    it("should export to WIF", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const key = bip32.BIP32.fromBase58(xprv);
+        const wif = key.toWIF();
+        assert.ok(typeof wif === "string");
+        assert.ok(wif.length > 0);
+    });
+    it("should fail to export WIF from public key", () => {
+        const xpub = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5";
+        const key = bip32.BIP32.fromBase58(xpub);
+        assert.throws(() => {
+            key.toWIF();
+        });
+    });
+    it("should create from seed", () => {
+        const seed = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            seed[i] = i;
+        }
+        const key = bip32.BIP32.fromSeed(seed);
+        assert.strictEqual(key.depth, 0);
+        assert.strictEqual(key.isNeutered(), false);
+        assert.ok(key.privateKey instanceof Uint8Array);
+    });
+    it("should create from seed with network", () => {
+        const seed = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            seed[i] = i;
+        }
+        const key = bip32.BIP32.fromSeed(seed, "BitcoinTestnet3");
+        assert.strictEqual(key.depth, 0);
+        assert.strictEqual(key.isNeutered(), false);
+        assert.ok(key.toBase58().startsWith("tprv"));
+    });
+});
+describe("WasmBIP32 parity with utxolib", () => {
+    function bufferEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    it("should match utxolib when creating from base58 xpub", () => {
+        const xpub = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5";
+        const wasmKey = bip32.BIP32.fromBase58(xpub);
+        const utxolibKey = utxolibBip32.fromBase58(xpub);
+        // Compare all properties
+        assert.strictEqual(wasmKey.toBase58(), utxolibKey.toBase58());
+        assert.strictEqual(wasmKey.depth, utxolibKey.depth);
+        assert.strictEqual(wasmKey.index, utxolibKey.index);
+        assert.strictEqual(wasmKey.parentFingerprint, utxolibKey.parentFingerprint);
+        assert.strictEqual(wasmKey.isNeutered(), utxolibKey.isNeutered());
+        assert.ok(bufferEqual(wasmKey.chainCode, utxolibKey.chainCode));
+        assert.ok(bufferEqual(wasmKey.publicKey, utxolibKey.publicKey));
+        assert.ok(bufferEqual(wasmKey.identifier, utxolibKey.identifier));
+        assert.ok(bufferEqual(wasmKey.fingerprint, utxolibKey.fingerprint));
+    });
+    it("should match utxolib when creating from base58 xprv", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        // Compare all properties
+        assert.strictEqual(wasmKey.toBase58(), utxolibKey.toBase58());
+        assert.strictEqual(wasmKey.depth, utxolibKey.depth);
+        assert.strictEqual(wasmKey.index, utxolibKey.index);
+        assert.strictEqual(wasmKey.parentFingerprint, utxolibKey.parentFingerprint);
+        assert.strictEqual(wasmKey.isNeutered(), utxolibKey.isNeutered());
+        assert.ok(bufferEqual(wasmKey.chainCode, utxolibKey.chainCode));
+        assert.ok(bufferEqual(wasmKey.publicKey, utxolibKey.publicKey));
+        assert.ok(bufferEqual(wasmKey.identifier, utxolibKey.identifier));
+        assert.ok(bufferEqual(wasmKey.fingerprint, utxolibKey.fingerprint));
+        assert.ok(wasmKey.privateKey &&
+            utxolibKey.privateKey &&
+            bufferEqual(wasmKey.privateKey, utxolibKey.privateKey));
+    });
+    it("should match utxolib when deriving normal child keys", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        // Derive several children and compare
+        for (const index of [0, 1, 10, 100, 2147483647]) {
+            const wasmChild = wasmKey.derive(index);
+            const utxolibChild = utxolibKey.derive(index);
+            assert.strictEqual(wasmChild.toBase58(), utxolibChild.toBase58(), `Failed at index ${index}`);
+            assert.ok(bufferEqual(wasmChild.publicKey, utxolibChild.publicKey));
+            assert.ok(bufferEqual(wasmChild.chainCode, utxolibChild.chainCode));
+        }
+    });
+    it("should match utxolib when deriving hardened child keys", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        // Derive several hardened children and compare
+        for (const index of [0, 1, 10, 2147483647]) {
+            const wasmChild = wasmKey.deriveHardened(index);
+            const utxolibChild = utxolibKey.deriveHardened(index);
+            assert.strictEqual(wasmChild.toBase58(), utxolibChild.toBase58(), `Failed at hardened index ${index}`);
+            assert.ok(bufferEqual(wasmChild.publicKey, utxolibChild.publicKey));
+            assert.ok(bufferEqual(wasmChild.chainCode, utxolibChild.chainCode));
+        }
+    });
+    it("should match utxolib when deriving using paths", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        const paths = ["0", "0/1", "0/1/2", "m/0/1/2", "0'/1", "m/44'/0'/0'", "m/44'/0'/0'/0/0"];
+        for (const path of paths) {
+            const wasmDerived = wasmKey.derivePath(path);
+            const utxolibDerived = utxolibKey.derivePath(path);
+            assert.strictEqual(wasmDerived.toBase58(), utxolibDerived.toBase58(), `Failed at path ${path}`);
+            assert.ok(bufferEqual(wasmDerived.publicKey, utxolibDerived.publicKey));
+            assert.ok(bufferEqual(wasmDerived.chainCode, utxolibDerived.chainCode));
+        }
+    });
+    it("should match utxolib when deriving from public keys", () => {
+        const xpub = "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5";
+        const wasmKey = bip32.BIP32.fromBase58(xpub);
+        const utxolibKey = utxolibBip32.fromBase58(xpub);
+        // Derive several children from public key
+        for (const index of [0, 1, 10, 100]) {
+            const wasmChild = wasmKey.derive(index);
+            const utxolibChild = utxolibKey.derive(index);
+            assert.strictEqual(wasmChild.toBase58(), utxolibChild.toBase58());
+            assert.ok(bufferEqual(wasmChild.publicKey, utxolibChild.publicKey));
+        }
+    });
+    it("should match utxolib when neutering", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        const wasmNeutered = wasmKey.neutered();
+        const utxolibNeutered = utxolibKey.neutered();
+        assert.strictEqual(wasmNeutered.toBase58(), utxolibNeutered.toBase58());
+        assert.ok(bufferEqual(wasmNeutered.publicKey, utxolibNeutered.publicKey));
+        assert.ok(bufferEqual(wasmNeutered.chainCode, utxolibNeutered.chainCode));
+        assert.strictEqual(wasmNeutered.privateKey, undefined);
+    });
+    it("should match utxolib when exporting to WIF", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        assert.strictEqual(wasmKey.toWIF(), utxolibKey.toWIF());
+    });
+    it("should match utxolib for BIP44 wallet derivation (m/44'/0'/0'/0/0)", () => {
+        const seed = Buffer.from("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542", "hex");
+        const wasmMaster = bip32.BIP32.fromSeed(seed);
+        const utxolibMaster = utxolibBip32.fromSeed(seed);
+        // Standard BIP44 path for Bitcoin: m/44'/0'/0'/0/0
+        const path = "m/44'/0'/0'/0/0";
+        const wasmDerived = wasmMaster.derivePath(path);
+        const utxolibDerived = utxolibMaster.derivePath(path);
+        assert.strictEqual(wasmDerived.toBase58(), utxolibDerived.toBase58());
+        assert.ok(bufferEqual(wasmDerived.publicKey, utxolibDerived.publicKey));
+        assert.ok(bufferEqual(wasmDerived.chainCode, utxolibDerived.chainCode));
+    });
+    it("should produce same fingerprint for derived keys", () => {
+        const xprv = "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi";
+        const wasmKey = bip32.BIP32.fromBase58(xprv);
+        const utxolibKey = utxolibBip32.fromBase58(xprv);
+        // Derive a child and check its parent fingerprint matches the parent's fingerprint
+        const wasmChild = wasmKey.derive(0);
+        const utxolibChild = utxolibKey.derive(0);
+        // Parent fingerprints should match
+        assert.strictEqual(wasmChild.parentFingerprint, utxolibChild.parentFingerprint);
+        // The parent fingerprint should match the parent's fingerprint
+        const wasmParentFp = new DataView(wasmKey.fingerprint.buffer).getUint32(0, false);
+        assert.strictEqual(wasmChild.parentFingerprint, wasmParentFp);
+    });
+});

package/dist/esm/test/ecpair.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/test/ecpair.js

@@ -0,0 +1,137 @@
+import * as assert from "assert";
+import { ECPair } from "../js/ecpair.js";
+describe("WasmECPair", () => {
+    const testPrivateKey = Buffer.from("1111111111111111111111111111111111111111111111111111111111111111", "hex");
+    const testWifMainnet = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn";
+    const testWifTestnet = "cMahea7zqjxrtgAbB7LSGbcQUr1uX1ojuat9jZodMN87JcbXMTcA";
+    it("should create from private key", () => {
+        const key = ECPair.fromPrivateKey(testPrivateKey);
+        assert.ok(key.privateKey instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+        assert.strictEqual(key.privateKey.length, 32);
+        assert.strictEqual(key.publicKey.length, 33); // Always compressed
+    });
+    it("should create from public key", () => {
+        const tempKey = ECPair.fromPrivateKey(testPrivateKey);
+        const publicKey = tempKey.publicKey;
+        const key = ECPair.fromPublicKey(publicKey);
+        assert.strictEqual(key.privateKey, undefined);
+        assert.ok(key.publicKey instanceof Uint8Array);
+        assert.strictEqual(key.publicKey.length, 33);
+    });
+    it("should create from mainnet WIF", () => {
+        const key = ECPair.fromWIF(testWifMainnet);
+        assert.ok(key.privateKey instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+        assert.strictEqual(key.privateKey.length, 32);
+    });
+    it("should create from testnet WIF", () => {
+        const key = ECPair.fromWIF(testWifTestnet);
+        assert.ok(key.privateKey instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+        assert.strictEqual(key.privateKey.length, 32);
+    });
+    it("should create from mainnet WIF using fromWIFMainnet", () => {
+        const key = ECPair.fromWIFMainnet(testWifMainnet);
+        assert.ok(key.privateKey instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+    });
+    it("should create from testnet WIF using fromWIFTestnet", () => {
+        const key = ECPair.fromWIFTestnet(testWifTestnet);
+        assert.ok(key.privateKey instanceof Uint8Array);
+        assert.ok(key.publicKey instanceof Uint8Array);
+    });
+    it("should fail when using wrong network WIF method", () => {
+        assert.throws(() => {
+            ECPair.fromWIFMainnet(testWifTestnet);
+        });
+        assert.throws(() => {
+            ECPair.fromWIFTestnet(testWifMainnet);
+        });
+    });
+    it("should export to WIF mainnet", () => {
+        const key = ECPair.fromPrivateKey(testPrivateKey);
+        const wif = key.toWIF();
+        assert.ok(typeof wif === "string");
+        assert.ok(wif.length > 0);
+        assert.ok(wif.startsWith("K") || wif.startsWith("L")); // Mainnet compressed
+    });
+    it("should export to WIF testnet", () => {
+        const key = ECPair.fromPrivateKey(testPrivateKey);
+        const wif = key.toWIFTestnet();
+        assert.ok(typeof wif === "string");
+        assert.ok(wif.length > 0);
+        assert.ok(wif.startsWith("c")); // Testnet compressed
+    });
+    it("should roundtrip WIF mainnet", () => {
+        const key1 = ECPair.fromPrivateKey(testPrivateKey);
+        const wif = key1.toWIF();
+        const key2 = ECPair.fromWIF(wif);
+        assert.deepStrictEqual(key1.privateKey, key2.privateKey);
+        assert.deepStrictEqual(key1.publicKey, key2.publicKey);
+    });
+    it("should roundtrip WIF testnet", () => {
+        const key1 = ECPair.fromPrivateKey(testPrivateKey);
+        const wif = key1.toWIFTestnet();
+        const key2 = ECPair.fromWIF(wif);
+        assert.deepStrictEqual(key1.privateKey, key2.privateKey);
+        assert.deepStrictEqual(key1.publicKey, key2.publicKey);
+    });
+    it("should fail to export WIF from public key", () => {
+        const tempKey = ECPair.fromPrivateKey(testPrivateKey);
+        const publicKey = tempKey.publicKey;
+        const key = ECPair.fromPublicKey(publicKey);
+        assert.throws(() => {
+            key.toWIF();
+        });
+        assert.throws(() => {
+            key.toWIFMainnet();
+        });
+        assert.throws(() => {
+            key.toWIFTestnet();
+        });
+    });
+    it("should reject invalid private keys", () => {
+        // All zeros
+        assert.throws(() => {
+            ECPair.fromPrivateKey(new Uint8Array(32));
+        });
+        // Wrong length
+        assert.throws(() => {
+            ECPair.fromPrivateKey(new Uint8Array(31));
+        });
+        assert.throws(() => {
+            ECPair.fromPrivateKey(new Uint8Array(33));
+        });
+    });
+    it("should reject invalid public keys", () => {
+        // Wrong length
+        assert.throws(() => {
+            ECPair.fromPublicKey(new Uint8Array(32));
+        });
+        assert.throws(() => {
+            ECPair.fromPublicKey(new Uint8Array(34));
+        });
+        // Invalid format
+        assert.throws(() => {
+            const invalidPubkey = new Uint8Array(33);
+            invalidPubkey[0] = 0x01; // Invalid prefix
+            ECPair.fromPublicKey(invalidPubkey);
+        });
+    });
+    it("should always produce compressed public keys", () => {
+        const key1 = ECPair.fromPrivateKey(testPrivateKey);
+        const key2 = ECPair.fromWIF(testWifMainnet);
+        // All public keys should be 33 bytes (compressed)
+        assert.strictEqual(key1.publicKey.length, 33);
+        assert.strictEqual(key2.publicKey.length, 33);
+        // All should start with 0x02 or 0x03 (compressed format)
+        assert.ok(key1.publicKey[0] === 0x02 || key1.publicKey[0] === 0x03);
+        assert.ok(key2.publicKey[0] === 0x02 || key2.publicKey[0] === 0x03);
+    });
+    it("should derive same public key from same private key", () => {
+        const key1 = ECPair.fromPrivateKey(testPrivateKey);
+        const key2 = ECPair.fromPrivateKey(testPrivateKey);
+        assert.deepStrictEqual(key1.publicKey, key2.publicKey);
+    });
+});

package/dist/esm/test/fixedScript/fixtureUtil.d.ts

@@ -1,4 +1,6 @@
-import * as utxolib from "@bitgo/utxo-lib";
+import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
+import { ECPair } from "../../js/ecpair.js";
+import type { BitGoPsbt, NetworkName } from "../../js/fixedScriptWallet/index.js";
 export type SignatureState = "unsigned" | "halfsigned" | "fullsigned";
 export type Triple<T> = [T, T, T];
 export type Bip32Derivation = {
@@ -79,6 +81,13 @@ export type Fixture = {
  * Get PSBT buffer from a fixture
  */
 export declare function getPsbtBuffer(fixture: Fixture): Buffer;
+/**
+ * Get BitGoPsbt from a fixture
+ * @param fixture - The test fixture
+ * @param networkName - The network name for deserializing the PSBT
+ * @returns A BitGoPsbt instance
+ */
+export declare function getBitGoPsbt(fixture: Fixture, networkName: NetworkName): BitGoPsbt;
 /**
  * Load a PSBT fixture from JSON file
  */
@@ -86,7 +95,8 @@ export declare function loadPsbtFixture(network: string, signatureState: string)
 /**
  * Load wallet keys from fixture
  */
-export declare function loadWalletKeysFromFixture(network: string): utxolib.bitgo.RootWalletKeys;
+export declare function loadWalletKeysFromFixture(fixture: Fixture): RootWalletKeys;
+export declare function loadReplayProtectionKeyFromFixture(fixture: Fixture): ECPair;
 /**
  * Get extracted transaction hex from fixture
  */

package/dist/esm/test/fixedScript/fixtureUtil.js

@@ -1,8 +1,12 @@
+import assert from "node:assert";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
-import * as utxolib from "@bitgo/utxo-lib";
+import { BIP32 } from "../../js/bip32.js";
+import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
+import { ECPair } from "../../js/ecpair.js";
+import { fixedScriptWallet } from "../../js/index.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -11,6 +15,15 @@ const __dirname = dirname(__filename);
 export function getPsbtBuffer(fixture) {
     return Buffer.from(fixture.psbtBase64, "base64");
 }
+/**
+ * Get BitGoPsbt from a fixture
+ * @param fixture - The test fixture
+ * @param networkName - The network name for deserializing the PSBT
+ * @returns A BitGoPsbt instance
+ */
+export function getBitGoPsbt(fixture, networkName) {
+    return fixedScriptWallet.BitGoPsbt.fromBytes(getPsbtBuffer(fixture), networkName);
+}
 /**
  * Load a PSBT fixture from JSON file
  */
@@ -22,16 +35,24 @@ export function loadPsbtFixture(network, signatureState) {
 /**
  * Load wallet keys from fixture
  */
-export function loadWalletKeysFromFixture(network) {
-    const fixturePath = path.join(__dirname, "..", "fixtures", "fixed-script", `psbt-lite.${network}.fullsigned.json`);
-    const fixtureContent = fs.readFileSync(fixturePath, "utf-8");
-    const fixture = JSON.parse(fixtureContent);
+export function loadWalletKeysFromFixture(fixture) {
     // Parse xprvs and convert to xpubs
     const xpubs = fixture.walletKeys.map((xprv) => {
-        const key = utxolib.bip32.fromBase58(xprv);
+        const key = BIP32.fromBase58(xprv);
         return key.neutered();
     });
-    return new utxolib.bitgo.RootWalletKeys(xpubs);
+    const walletKeysLike = {
+        triple: xpubs,
+        derivationPrefixes: ["0/0", "0/0", "0/0"],
+    };
+    return RootWalletKeys.from(walletKeysLike);
+}
+export function loadReplayProtectionKeyFromFixture(fixture) {
+    // underived user key
+    const userBip32 = BIP32.fromBase58(fixture.walletKeys[0]);
+    assert(userBip32.privateKey);
+    const userECPair = ECPair.fromPrivateKey(Buffer.from(userBip32.privateKey));
+    return userECPair;
 }
 /**
  * Get extracted transaction hex from fixture

package/dist/esm/test/fixedScript/musig2Nonces.d.ts

@@ -0,0 +1 @@
+export {};