@bitgo/wasm-utxo 1.6.0 → 1.7.0

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

@@ -1,28 +1,68 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_utxolibcompatnamespace_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 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 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_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_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 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 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_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_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;
@@ -48,6 +88,11 @@ export const wrappsbt_signWithPrv: (a: number, b: number, c: number, d: number)
 export const wrappsbt_signWithXprv: (a: number, b: number, c: number, d: number) => void;
 export const wrappsbt_updateInputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
 export const wrappsbt_updateOutputWithDescriptor: (a: number, b: number, c: number, d: number) => void;
+export const __wbg_fixedscriptwalletnamespace_free: (a: number, b: number) => void;
+export const __wbg_wasmreplayprotection_free: (a: number, b: 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 rustsecp256k1_v0_10_0_context_create: (a: number) => number;
 export const rustsecp256k1_v0_10_0_context_destroy: (a: number) => void;
 export const rustsecp256k1_v0_10_0_default_error_callback_fn: (a: number, b: number) => void;

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

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

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,5 @@
-import * as utxolib from "@bitgo/utxo-lib";
+import { RootWalletKeys } from "../../js/fixedScriptWallet/RootWalletKeys.js";
+import { ECPair } from "../../js/ecpair.js";
 export type SignatureState = "unsigned" | "halfsigned" | "fullsigned";
 export type Triple<T> = [T, T, T];
 export type Bip32Derivation = {
@@ -86,7 +87,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,11 @@
+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";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -22,16 +25,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/parseTransactionWithWalletKeys.js

@@ -1,7 +1,7 @@
 import assert from "node:assert";
 import * as utxolib from "@bitgo/utxo-lib";
 import { fixedScriptWallet } from "../../js/index.js";
-import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer } from "./fixtureUtil.js";
+import { loadPsbtFixture, loadWalletKeysFromFixture, getPsbtBuffer, loadReplayProtectionKeyFromFixture, } from "./fixtureUtil.js";
 function getExpectedInputScriptType(fixtureScriptType) {
     // Map fixture types to InputScriptType values
     // Based on the Rust mapping in src/fixed_script_wallet/test_utils/fixtures.rs
@@ -26,8 +26,6 @@ function getOtherWalletKeys() {
     return new utxolib.bitgo.RootWalletKeys(otherWalletKeys);
 }
 describe("parseTransactionWithWalletKeys", function () {
-    // Replay protection script that matches Rust tests
-    const replayProtectionScript = Buffer.from("a91420b37094d82a513451ff0ccd9db23aba05bc5ef387", "hex");
     const supportedNetworks = utxolib.getNetworkList().filter((network) => {
         return (utxolib.isMainnet(network) &&
             network !== utxolib.networks.bitcoincash &&
@@ -42,12 +40,14 @@ describe("parseTransactionWithWalletKeys", function () {
             let fullsignedPsbtBytes;
             let bitgoPsbt;
             let rootWalletKeys;
+            let replayProtectionKey;
             let fixture;
             before(function () {
                 fixture = loadPsbtFixture(networkName, "fullsigned");
                 fullsignedPsbtBytes = getPsbtBuffer(fixture);
                 bitgoPsbt = fixedScriptWallet.BitGoPsbt.fromBytes(fullsignedPsbtBytes, networkName);
-                rootWalletKeys = loadWalletKeysFromFixture(networkName);
+                rootWalletKeys = loadWalletKeysFromFixture(fixture);
+                replayProtectionKey = loadReplayProtectionKeyFromFixture(fixture);
             });
             it("should have matching unsigned transaction ID", function () {
                 const unsignedTxid = bitgoPsbt.unsignedTxid();
@@ -59,7 +59,7 @@ describe("parseTransactionWithWalletKeys", function () {
             });
             it("should parse transaction and identify internal/external outputs", function () {
                 const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-                    outputScripts: [replayProtectionScript],
+                    publicKeys: [replayProtectionKey],
                 });
                 // Verify all inputs have addresses and values
                 parsed.inputs.forEach((input, i) => {
@@ -104,7 +104,7 @@ describe("parseTransactionWithWalletKeys", function () {
             });
             it("should parse inputs with correct scriptType", function () {
                 const parsed = bitgoPsbt.parseTransactionWithWalletKeys(rootWalletKeys, {
-                    outputScripts: [replayProtectionScript],
+                    publicKeys: [replayProtectionKey],
                 });
                 // Verify all inputs have scriptType matching fixture
                 parsed.inputs.forEach((input, i) => {
@@ -116,7 +116,7 @@ describe("parseTransactionWithWalletKeys", function () {
             it("should fail to parse with other wallet keys", function () {
                 assert.throws(() => {
                     bitgoPsbt.parseTransactionWithWalletKeys(getOtherWalletKeys(), {
-                        outputScripts: [replayProtectionScript],
+                        publicKeys: [replayProtectionKey],
                     });
                 }, (error) => {
                     return error.message.includes("Failed to parse transaction: Input 0: wallet validation failed");