FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@scure/bip32/lib/esm/index.d.ts

@@ -0,0 +1,50 @@
+export declare const HARDENED_OFFSET: number;
+export interface Versions {
+    private: number;
+    public: number;
+}
+interface HDKeyOpt {
+    versions?: Versions;
+    depth?: number;
+    index?: number;
+    parentFingerprint?: number;
+    chainCode?: Uint8Array;
+    publicKey?: Uint8Array;
+    privateKey?: Uint8Array | bigint;
+}
+export declare class HDKey {
+    get fingerprint(): number;
+    get identifier(): Uint8Array | undefined;
+    get pubKeyHash(): Uint8Array | undefined;
+    get privateKey(): Uint8Array | null;
+    get publicKey(): Uint8Array | null;
+    get privateExtendedKey(): string;
+    get publicExtendedKey(): string;
+    static fromMasterSeed(seed: Uint8Array, versions?: Versions): HDKey;
+    static fromExtendedKey(base58key: string, versions?: Versions): HDKey;
+    static fromJSON(json: {
+        xpriv: string;
+    }): HDKey;
+    readonly versions: Versions;
+    readonly depth: number;
+    readonly index: number;
+    readonly chainCode: Uint8Array | null;
+    readonly parentFingerprint: number;
+    private privKey?;
+    private privKeyBytes?;
+    private pubKey?;
+    private pubHash;
+    constructor(opt: HDKeyOpt);
+    derive(path: string): HDKey;
+    deriveChild(index: number): HDKey;
+    sign(hash: Uint8Array): Uint8Array;
+    verify(hash: Uint8Array, signature: Uint8Array): boolean;
+    wipePrivateData(): this;
+    toJSON(): {
+        xpriv: string;
+        xpub: string;
+    };
+    private serialize;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

node_modules/@scure/bip32/lib/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,eAAe,EAAE,MAAmB,CAAC;AAElD,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAaD,UAAU,QAAQ;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAClC;AAED,qBAAa,KAAK;IAChB,IAAI,WAAW,IAAI,MAAM,CAKxB;IACD,IAAI,UAAU,IAAI,UAAU,GAAG,SAAS,CAEvC;IACD,IAAI,UAAU,IAAI,UAAU,GAAG,SAAS,CAEvC;IACD,IAAI,UAAU,IAAI,UAAU,GAAG,IAAI,CAElC;IACD,IAAI,SAAS,IAAI,UAAU,GAAG,IAAI,CAEjC;IACD,IAAI,kBAAkB,IAAI,MAAM,CAQ/B;IACD,IAAI,iBAAiB,IAAI,MAAM,CAK9B;WAEa,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,GAAE,QAA2B,GAAG,KAAK;WAgB9E,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,QAA2B,GAAG,KAAK;WAwBhF,QAAQ,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK;IAGtD,SAAgB,QAAQ,EAAE,QAAQ,CAAC;IACnC,SAAgB,KAAK,EAAE,MAAM,CAAK;IAClC,SAAgB,KAAK,EAAE,MAAM,CAAK;IAClC,SAAgB,SAAS,EAAE,UAAU,GAAG,IAAI,CAAQ;IACpD,SAAgB,iBAAiB,EAAE,MAAM,CAAK;IAC9C,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,YAAY,CAAC,CAAa;IAClC,OAAO,CAAC,MAAM,CAAC,CAAa;IAC5B,OAAO,CAAC,OAAO,CAAyB;gBAE5B,GAAG,EAAE,QAAQ;IAiClB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IA4B3B,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAoDjC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IAQlC,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO;IAexD,eAAe,IAAI,IAAI;IAQvB,MAAM,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAOhD,OAAO,CAAC,SAAS;CAelB"}

node_modules/@scure/bip32/lib/esm/index.js

@@ -0,0 +1,288 @@
+/**
+ * @module BIP32 hierarchical deterministic (HD) wallets over secp256k1.
+ * @example
+ * ```js
+ * import { HDKey } from "@scure/bip32";
+ * const hdkey1 = HDKey.fromMasterSeed(seed);
+ * const hdkey2 = HDKey.fromExtendedKey(base58key);
+ * const hdkey3 = HDKey.fromJSON({ xpriv: string });
+ *
+ * // props
+ * [hdkey1.depth, hdkey1.index, hdkey1.chainCode];
+ * console.log(hdkey2.privateKey, hdkey2.publicKey);
+ * console.log(hdkey3.derive("m/0/2147483647'/1"));
+ * const sig = hdkey3.sign(hash);
+ * hdkey3.verify(hash, sig);
+ * ```
+ */
+/*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+import { mod } from '@noble/curves/abstract/modular';
+import { secp256k1 as secp } from '@noble/curves/secp256k1';
+import { hmac } from '@noble/hashes/hmac';
+import { ripemd160 } from '@noble/hashes/legacy';
+import { sha256, sha512 } from '@noble/hashes/sha2';
+import { abytes, bytesToHex, concatBytes, createView, hexToBytes, utf8ToBytes, } from '@noble/hashes/utils';
+import { createBase58check } from '@scure/base';
+const Point = secp.ProjectivePoint;
+const base58check = createBase58check(sha256);
+function bytesToNumber(bytes) {
+    abytes(bytes);
+    const h = bytes.length === 0 ? '0' : bytesToHex(bytes);
+    return BigInt('0x' + h);
+}
+function numberToBytes(num) {
+    if (typeof num !== 'bigint')
+        throw new Error('bigint expected');
+    return hexToBytes(num.toString(16).padStart(64, '0'));
+}
+const MASTER_SECRET = utf8ToBytes('Bitcoin seed');
+// Bitcoin hardcoded by default
+const BITCOIN_VERSIONS = { private: 0x0488ade4, public: 0x0488b21e };
+export const HARDENED_OFFSET = 0x80000000;
+const hash160 = (data) => ripemd160(sha256(data));
+const fromU32 = (data) => createView(data).getUint32(0, false);
+const toU32 = (n) => {
+    if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {
+        throw new Error('invalid number, should be from 0 to 2**32-1, got ' + n);
+    }
+    const buf = new Uint8Array(4);
+    createView(buf).setUint32(0, n, false);
+    return buf;
+};
+export class HDKey {
+    get fingerprint() {
+        if (!this.pubHash) {
+            throw new Error('No publicKey set!');
+        }
+        return fromU32(this.pubHash);
+    }
+    get identifier() {
+        return this.pubHash;
+    }
+    get pubKeyHash() {
+        return this.pubHash;
+    }
+    get privateKey() {
+        return this.privKeyBytes || null;
+    }
+    get publicKey() {
+        return this.pubKey || null;
+    }
+    get privateExtendedKey() {
+        const priv = this.privateKey;
+        if (!priv) {
+            throw new Error('No private key');
+        }
+        return base58check.encode(this.serialize(this.versions.private, concatBytes(new Uint8Array([0]), priv)));
+    }
+    get publicExtendedKey() {
+        if (!this.pubKey) {
+            throw new Error('No public key');
+        }
+        return base58check.encode(this.serialize(this.versions.public, this.pubKey));
+    }
+    static fromMasterSeed(seed, versions = BITCOIN_VERSIONS) {
+        abytes(seed);
+        if (8 * seed.length < 128 || 8 * seed.length > 512) {
+            throw new Error('HDKey: seed length must be between 128 and 512 bits; 256 bits is advised, got ' +
+                seed.length);
+        }
+        const I = hmac(sha512, MASTER_SECRET, seed);
+        return new HDKey({
+            versions,
+            chainCode: I.slice(32),
+            privateKey: I.slice(0, 32),
+        });
+    }
+    static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {
+        // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+        const keyBuffer = base58check.decode(base58key);
+        const keyView = createView(keyBuffer);
+        const version = keyView.getUint32(0, false);
+        const opt = {
+            versions,
+            depth: keyBuffer[4],
+            parentFingerprint: keyView.getUint32(5, false),
+            index: keyView.getUint32(9, false),
+            chainCode: keyBuffer.slice(13, 45),
+        };
+        const key = keyBuffer.slice(45);
+        const isPriv = key[0] === 0;
+        if (version !== versions[isPriv ? 'private' : 'public']) {
+            throw new Error('Version mismatch');
+        }
+        if (isPriv) {
+            return new HDKey({ ...opt, privateKey: key.slice(1) });
+        }
+        else {
+            return new HDKey({ ...opt, publicKey: key });
+        }
+    }
+    static fromJSON(json) {
+        return HDKey.fromExtendedKey(json.xpriv);
+    }
+    constructor(opt) {
+        this.depth = 0;
+        this.index = 0;
+        this.chainCode = null;
+        this.parentFingerprint = 0;
+        if (!opt || typeof opt !== 'object') {
+            throw new Error('HDKey.constructor must not be called directly');
+        }
+        this.versions = opt.versions || BITCOIN_VERSIONS;
+        this.depth = opt.depth || 0;
+        this.chainCode = opt.chainCode || null;
+        this.index = opt.index || 0;
+        this.parentFingerprint = opt.parentFingerprint || 0;
+        if (!this.depth) {
+            if (this.parentFingerprint || this.index) {
+                throw new Error('HDKey: zero depth with non-zero index/parent fingerprint');
+            }
+        }
+        if (opt.publicKey && opt.privateKey) {
+            throw new Error('HDKey: publicKey and privateKey at same time.');
+        }
+        if (opt.privateKey) {
+            if (!secp.utils.isValidPrivateKey(opt.privateKey)) {
+                throw new Error('Invalid private key');
+            }
+            this.privKey =
+                typeof opt.privateKey === 'bigint' ? opt.privateKey : bytesToNumber(opt.privateKey);
+            this.privKeyBytes = numberToBytes(this.privKey);
+            this.pubKey = secp.getPublicKey(opt.privateKey, true);
+        }
+        else if (opt.publicKey) {
+            this.pubKey = Point.fromHex(opt.publicKey).toRawBytes(true); // force compressed point
+        }
+        else {
+            throw new Error('HDKey: no public or private key provided');
+        }
+        this.pubHash = hash160(this.pubKey);
+    }
+    derive(path) {
+        if (!/^[mM]'?/.test(path)) {
+            throw new Error('Path must start with "m" or "M"');
+        }
+        if (/^[mM]'?$/.test(path)) {
+            return this;
+        }
+        const parts = path.replace(/^[mM]'?\//, '').split('/');
+        // tslint:disable-next-line
+        let child = this;
+        for (const c of parts) {
+            const m = /^(\d+)('?)$/.exec(c);
+            const m1 = m && m[1];
+            if (!m || m.length !== 3 || typeof m1 !== 'string')
+                throw new Error('invalid child index: ' + c);
+            let idx = +m1;
+            if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET) {
+                throw new Error('Invalid index');
+            }
+            // hardened key
+            if (m[2] === "'") {
+                idx += HARDENED_OFFSET;
+            }
+            child = child.deriveChild(idx);
+        }
+        return child;
+    }
+    deriveChild(index) {
+        if (!this.pubKey || !this.chainCode) {
+            throw new Error('No publicKey or chainCode set');
+        }
+        let data = toU32(index);
+        if (index >= HARDENED_OFFSET) {
+            // Hardened
+            const priv = this.privateKey;
+            if (!priv) {
+                throw new Error('Could not derive hardened child key');
+            }
+            // Hardened child: 0x00 || ser256(kpar) || ser32(index)
+            data = concatBytes(new Uint8Array([0]), priv, data);
+        }
+        else {
+            // Normal child: serP(point(kpar)) || ser32(index)
+            data = concatBytes(this.pubKey, data);
+        }
+        const I = hmac(sha512, this.chainCode, data);
+        const childTweak = bytesToNumber(I.slice(0, 32));
+        const chainCode = I.slice(32);
+        if (!secp.utils.isValidPrivateKey(childTweak)) {
+            throw new Error('Tweak bigger than curve order');
+        }
+        const opt = {
+            versions: this.versions,
+            chainCode,
+            depth: this.depth + 1,
+            parentFingerprint: this.fingerprint,
+            index,
+        };
+        try {
+            // Private parent key -> private child key
+            if (this.privateKey) {
+                const added = mod(this.privKey + childTweak, secp.CURVE.n);
+                if (!secp.utils.isValidPrivateKey(added)) {
+                    throw new Error('The tweak was out of range or the resulted private key is invalid');
+                }
+                opt.privateKey = added;
+            }
+            else {
+                const added = Point.fromHex(this.pubKey).add(Point.fromPrivateKey(childTweak));
+                // Cryptographically impossible: hmac-sha512 preimage would need to be found
+                if (added.equals(Point.ZERO)) {
+                    throw new Error('The tweak was equal to negative P, which made the result key invalid');
+                }
+                opt.publicKey = added.toRawBytes(true);
+            }
+            return new HDKey(opt);
+        }
+        catch (err) {
+            return this.deriveChild(index + 1);
+        }
+    }
+    sign(hash) {
+        if (!this.privateKey) {
+            throw new Error('No privateKey set!');
+        }
+        abytes(hash, 32);
+        return secp.sign(hash, this.privKey).toCompactRawBytes();
+    }
+    verify(hash, signature) {
+        abytes(hash, 32);
+        abytes(signature, 64);
+        if (!this.publicKey) {
+            throw new Error('No publicKey set!');
+        }
+        let sig;
+        try {
+            sig = secp.Signature.fromCompact(signature);
+        }
+        catch (error) {
+            return false;
+        }
+        return secp.verify(sig, hash, this.publicKey);
+    }
+    wipePrivateData() {
+        this.privKey = undefined;
+        if (this.privKeyBytes) {
+            this.privKeyBytes.fill(0);
+            this.privKeyBytes = undefined;
+        }
+        return this;
+    }
+    toJSON() {
+        return {
+            xpriv: this.privateExtendedKey,
+            xpub: this.publicExtendedKey,
+        };
+    }
+    serialize(version, key) {
+        if (!this.chainCode) {
+            throw new Error('No chainCode set');
+        }
+        abytes(key, 33);
+        // version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+        return concatBytes(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@scure/bip32/lib/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}

node_modules/@scure/bip32/lib/index.d.ts

@@ -0,0 +1,50 @@
+export declare const HARDENED_OFFSET: number;
+export interface Versions {
+    private: number;
+    public: number;
+}
+interface HDKeyOpt {
+    versions?: Versions;
+    depth?: number;
+    index?: number;
+    parentFingerprint?: number;
+    chainCode?: Uint8Array;
+    publicKey?: Uint8Array;
+    privateKey?: Uint8Array | bigint;
+}
+export declare class HDKey {
+    get fingerprint(): number;
+    get identifier(): Uint8Array | undefined;
+    get pubKeyHash(): Uint8Array | undefined;
+    get privateKey(): Uint8Array | null;
+    get publicKey(): Uint8Array | null;
+    get privateExtendedKey(): string;
+    get publicExtendedKey(): string;
+    static fromMasterSeed(seed: Uint8Array, versions?: Versions): HDKey;
+    static fromExtendedKey(base58key: string, versions?: Versions): HDKey;
+    static fromJSON(json: {
+        xpriv: string;
+    }): HDKey;
+    readonly versions: Versions;
+    readonly depth: number;
+    readonly index: number;
+    readonly chainCode: Uint8Array | null;
+    readonly parentFingerprint: number;
+    private privKey?;
+    private privKeyBytes?;
+    private pubKey?;
+    private pubHash;
+    constructor(opt: HDKeyOpt);
+    derive(path: string): HDKey;
+    deriveChild(index: number): HDKey;
+    sign(hash: Uint8Array): Uint8Array;
+    verify(hash: Uint8Array, signature: Uint8Array): boolean;
+    wipePrivateData(): this;
+    toJSON(): {
+        xpriv: string;
+        xpub: string;
+    };
+    private serialize;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

node_modules/@scure/bip32/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,eAAe,EAAE,MAAmB,CAAC;AAElD,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAaD,UAAU,QAAQ;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAClC;AAED,qBAAa,KAAK;IAChB,IAAI,WAAW,IAAI,MAAM,CAKxB;IACD,IAAI,UAAU,IAAI,UAAU,GAAG,SAAS,CAEvC;IACD,IAAI,UAAU,IAAI,UAAU,GAAG,SAAS,CAEvC;IACD,IAAI,UAAU,IAAI,UAAU,GAAG,IAAI,CAElC;IACD,IAAI,SAAS,IAAI,UAAU,GAAG,IAAI,CAEjC;IACD,IAAI,kBAAkB,IAAI,MAAM,CAQ/B;IACD,IAAI,iBAAiB,IAAI,MAAM,CAK9B;WAEa,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,GAAE,QAA2B,GAAG,KAAK;WAgB9E,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,QAA2B,GAAG,KAAK;WAwBhF,QAAQ,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK;IAGtD,SAAgB,QAAQ,EAAE,QAAQ,CAAC;IACnC,SAAgB,KAAK,EAAE,MAAM,CAAK;IAClC,SAAgB,KAAK,EAAE,MAAM,CAAK;IAClC,SAAgB,SAAS,EAAE,UAAU,GAAG,IAAI,CAAQ;IACpD,SAAgB,iBAAiB,EAAE,MAAM,CAAK;IAC9C,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,YAAY,CAAC,CAAa;IAClC,OAAO,CAAC,MAAM,CAAC,CAAa;IAC5B,OAAO,CAAC,OAAO,CAAyB;gBAE5B,GAAG,EAAE,QAAQ;IAiClB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IA4B3B,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IAoDjC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IAQlC,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO;IAexD,eAAe,IAAI,IAAI;IAQvB,MAAM,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAOhD,OAAO,CAAC,SAAS;CAelB"}

node_modules/@scure/bip32/lib/index.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HDKey = exports.HARDENED_OFFSET = void 0;
+/**
+ * @module BIP32 hierarchical deterministic (HD) wallets over secp256k1.
+ * @example
+ * ```js
+ * import { HDKey } from "@scure/bip32";
+ * const hdkey1 = HDKey.fromMasterSeed(seed);
+ * const hdkey2 = HDKey.fromExtendedKey(base58key);
+ * const hdkey3 = HDKey.fromJSON({ xpriv: string });
+ *
+ * // props
+ * [hdkey1.depth, hdkey1.index, hdkey1.chainCode];
+ * console.log(hdkey2.privateKey, hdkey2.publicKey);
+ * console.log(hdkey3.derive("m/0/2147483647'/1"));
+ * const sig = hdkey3.sign(hash);
+ * hdkey3.verify(hash, sig);
+ * ```
+ */
+/*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+const modular_1 = require("@noble/curves/abstract/modular");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const hmac_1 = require("@noble/hashes/hmac");
+const legacy_1 = require("@noble/hashes/legacy");
+const sha2_1 = require("@noble/hashes/sha2");
+const utils_1 = require("@noble/hashes/utils");
+const base_1 = require("@scure/base");
+const Point = secp256k1_1.secp256k1.ProjectivePoint;
+const base58check = (0, base_1.createBase58check)(sha2_1.sha256);
+function bytesToNumber(bytes) {
+    (0, utils_1.abytes)(bytes);
+    const h = bytes.length === 0 ? '0' : (0, utils_1.bytesToHex)(bytes);
+    return BigInt('0x' + h);
+}
+function numberToBytes(num) {
+    if (typeof num !== 'bigint')
+        throw new Error('bigint expected');
+    return (0, utils_1.hexToBytes)(num.toString(16).padStart(64, '0'));
+}
+const MASTER_SECRET = (0, utils_1.utf8ToBytes)('Bitcoin seed');
+// Bitcoin hardcoded by default
+const BITCOIN_VERSIONS = { private: 0x0488ade4, public: 0x0488b21e };
+exports.HARDENED_OFFSET = 0x80000000;
+const hash160 = (data) => (0, legacy_1.ripemd160)((0, sha2_1.sha256)(data));
+const fromU32 = (data) => (0, utils_1.createView)(data).getUint32(0, false);
+const toU32 = (n) => {
+    if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {
+        throw new Error('invalid number, should be from 0 to 2**32-1, got ' + n);
+    }
+    const buf = new Uint8Array(4);
+    (0, utils_1.createView)(buf).setUint32(0, n, false);
+    return buf;
+};
+class HDKey {
+    get fingerprint() {
+        if (!this.pubHash) {
+            throw new Error('No publicKey set!');
+        }
+        return fromU32(this.pubHash);
+    }
+    get identifier() {
+        return this.pubHash;
+    }
+    get pubKeyHash() {
+        return this.pubHash;
+    }
+    get privateKey() {
+        return this.privKeyBytes || null;
+    }
+    get publicKey() {
+        return this.pubKey || null;
+    }
+    get privateExtendedKey() {
+        const priv = this.privateKey;
+        if (!priv) {
+            throw new Error('No private key');
+        }
+        return base58check.encode(this.serialize(this.versions.private, (0, utils_1.concatBytes)(new Uint8Array([0]), priv)));
+    }
+    get publicExtendedKey() {
+        if (!this.pubKey) {
+            throw new Error('No public key');
+        }
+        return base58check.encode(this.serialize(this.versions.public, this.pubKey));
+    }
+    static fromMasterSeed(seed, versions = BITCOIN_VERSIONS) {
+        (0, utils_1.abytes)(seed);
+        if (8 * seed.length < 128 || 8 * seed.length > 512) {
+            throw new Error('HDKey: seed length must be between 128 and 512 bits; 256 bits is advised, got ' +
+                seed.length);
+        }
+        const I = (0, hmac_1.hmac)(sha2_1.sha512, MASTER_SECRET, seed);
+        return new HDKey({
+            versions,
+            chainCode: I.slice(32),
+            privateKey: I.slice(0, 32),
+        });
+    }
+    static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {
+        // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+        const keyBuffer = base58check.decode(base58key);
+        const keyView = (0, utils_1.createView)(keyBuffer);
+        const version = keyView.getUint32(0, false);
+        const opt = {
+            versions,
+            depth: keyBuffer[4],
+            parentFingerprint: keyView.getUint32(5, false),
+            index: keyView.getUint32(9, false),
+            chainCode: keyBuffer.slice(13, 45),
+        };
+        const key = keyBuffer.slice(45);
+        const isPriv = key[0] === 0;
+        if (version !== versions[isPriv ? 'private' : 'public']) {
+            throw new Error('Version mismatch');
+        }
+        if (isPriv) {
+            return new HDKey({ ...opt, privateKey: key.slice(1) });
+        }
+        else {
+            return new HDKey({ ...opt, publicKey: key });
+        }
+    }
+    static fromJSON(json) {
+        return HDKey.fromExtendedKey(json.xpriv);
+    }
+    constructor(opt) {
+        this.depth = 0;
+        this.index = 0;
+        this.chainCode = null;
+        this.parentFingerprint = 0;
+        if (!opt || typeof opt !== 'object') {
+            throw new Error('HDKey.constructor must not be called directly');
+        }
+        this.versions = opt.versions || BITCOIN_VERSIONS;
+        this.depth = opt.depth || 0;
+        this.chainCode = opt.chainCode || null;
+        this.index = opt.index || 0;
+        this.parentFingerprint = opt.parentFingerprint || 0;
+        if (!this.depth) {
+            if (this.parentFingerprint || this.index) {
+                throw new Error('HDKey: zero depth with non-zero index/parent fingerprint');
+            }
+        }
+        if (opt.publicKey && opt.privateKey) {
+            throw new Error('HDKey: publicKey and privateKey at same time.');
+        }
+        if (opt.privateKey) {
+            if (!secp256k1_1.secp256k1.utils.isValidPrivateKey(opt.privateKey)) {
+                throw new Error('Invalid private key');
+            }
+            this.privKey =
+                typeof opt.privateKey === 'bigint' ? opt.privateKey : bytesToNumber(opt.privateKey);
+            this.privKeyBytes = numberToBytes(this.privKey);
+            this.pubKey = secp256k1_1.secp256k1.getPublicKey(opt.privateKey, true);
+        }
+        else if (opt.publicKey) {
+            this.pubKey = Point.fromHex(opt.publicKey).toRawBytes(true); // force compressed point
+        }
+        else {
+            throw new Error('HDKey: no public or private key provided');
+        }
+        this.pubHash = hash160(this.pubKey);
+    }
+    derive(path) {
+        if (!/^[mM]'?/.test(path)) {
+            throw new Error('Path must start with "m" or "M"');
+        }
+        if (/^[mM]'?$/.test(path)) {
+            return this;
+        }
+        const parts = path.replace(/^[mM]'?\//, '').split('/');
+        // tslint:disable-next-line
+        let child = this;
+        for (const c of parts) {
+            const m = /^(\d+)('?)$/.exec(c);
+            const m1 = m && m[1];
+            if (!m || m.length !== 3 || typeof m1 !== 'string')
+                throw new Error('invalid child index: ' + c);
+            let idx = +m1;
+            if (!Number.isSafeInteger(idx) || idx >= exports.HARDENED_OFFSET) {
+                throw new Error('Invalid index');
+            }
+            // hardened key
+            if (m[2] === "'") {
+                idx += exports.HARDENED_OFFSET;
+            }
+            child = child.deriveChild(idx);
+        }
+        return child;
+    }
+    deriveChild(index) {
+        if (!this.pubKey || !this.chainCode) {
+            throw new Error('No publicKey or chainCode set');
+        }
+        let data = toU32(index);
+        if (index >= exports.HARDENED_OFFSET) {
+            // Hardened
+            const priv = this.privateKey;
+            if (!priv) {
+                throw new Error('Could not derive hardened child key');
+            }
+            // Hardened child: 0x00 || ser256(kpar) || ser32(index)
+            data = (0, utils_1.concatBytes)(new Uint8Array([0]), priv, data);
+        }
+        else {
+            // Normal child: serP(point(kpar)) || ser32(index)
+            data = (0, utils_1.concatBytes)(this.pubKey, data);
+        }
+        const I = (0, hmac_1.hmac)(sha2_1.sha512, this.chainCode, data);
+        const childTweak = bytesToNumber(I.slice(0, 32));
+        const chainCode = I.slice(32);
+        if (!secp256k1_1.secp256k1.utils.isValidPrivateKey(childTweak)) {
+            throw new Error('Tweak bigger than curve order');
+        }
+        const opt = {
+            versions: this.versions,
+            chainCode,
+            depth: this.depth + 1,
+            parentFingerprint: this.fingerprint,
+            index,
+        };
+        try {
+            // Private parent key -> private child key
+            if (this.privateKey) {
+                const added = (0, modular_1.mod)(this.privKey + childTweak, secp256k1_1.secp256k1.CURVE.n);
+                if (!secp256k1_1.secp256k1.utils.isValidPrivateKey(added)) {
+                    throw new Error('The tweak was out of range or the resulted private key is invalid');
+                }
+                opt.privateKey = added;
+            }
+            else {
+                const added = Point.fromHex(this.pubKey).add(Point.fromPrivateKey(childTweak));
+                // Cryptographically impossible: hmac-sha512 preimage would need to be found
+                if (added.equals(Point.ZERO)) {
+                    throw new Error('The tweak was equal to negative P, which made the result key invalid');
+                }
+                opt.publicKey = added.toRawBytes(true);
+            }
+            return new HDKey(opt);
+        }
+        catch (err) {
+            return this.deriveChild(index + 1);
+        }
+    }
+    sign(hash) {
+        if (!this.privateKey) {
+            throw new Error('No privateKey set!');
+        }
+        (0, utils_1.abytes)(hash, 32);
+        return secp256k1_1.secp256k1.sign(hash, this.privKey).toCompactRawBytes();
+    }
+    verify(hash, signature) {
+        (0, utils_1.abytes)(hash, 32);
+        (0, utils_1.abytes)(signature, 64);
+        if (!this.publicKey) {
+            throw new Error('No publicKey set!');
+        }
+        let sig;
+        try {
+            sig = secp256k1_1.secp256k1.Signature.fromCompact(signature);
+        }
+        catch (error) {
+            return false;
+        }
+        return secp256k1_1.secp256k1.verify(sig, hash, this.publicKey);
+    }
+    wipePrivateData() {
+        this.privKey = undefined;
+        if (this.privKeyBytes) {
+            this.privKeyBytes.fill(0);
+            this.privKeyBytes = undefined;
+        }
+        return this;
+    }
+    toJSON() {
+        return {
+            xpriv: this.privateExtendedKey,
+            xpub: this.publicExtendedKey,
+        };
+    }
+    serialize(version, key) {
+        if (!this.chainCode) {
+            throw new Error('No chainCode set');
+        }
+        (0, utils_1.abytes)(key, 33);
+        // version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+        return (0, utils_1.concatBytes)(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+    }
+}
+exports.HDKey = HDKey;
+//# sourceMappingURL=index.js.map