web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@protobufjs/path/index.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var index = require('../../../_virtual/index31.js');
+
+var hasRequiredPath;
+function requirePath() {
+  if (hasRequiredPath) return index.__exports;
+  hasRequiredPath = 1;
+  (function (exports) {
+
+    /**
+     * A minimal path module to resolve Unix, Windows and URL paths alike.
+     * @memberof util
+     * @namespace
+     */
+    var path = exports;
+    var isAbsolute =
+    /**
+     * Tests if the specified path is absolute.
+     * @param {string} path Path to test
+     * @returns {boolean} `true` if path is absolute
+     */
+    path.isAbsolute = function isAbsolute(path) {
+      return /^(?:\/|\w+:)/.test(path);
+    };
+    var normalize =
+    /**
+     * Normalizes the specified path.
+     * @param {string} path Path to normalize
+     * @returns {string} Normalized path
+     */
+    path.normalize = function normalize(path) {
+      path = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+      var parts = path.split("/"),
+        absolute = isAbsolute(path),
+        prefix = "";
+      if (absolute) prefix = parts.shift() + "/";
+      for (var i = 0; i < parts.length;) {
+        if (parts[i] === "..") {
+          if (i > 0 && parts[i - 1] !== "..") parts.splice(--i, 2);else if (absolute) parts.splice(i, 1);else ++i;
+        } else if (parts[i] === ".") parts.splice(i, 1);else ++i;
+      }
+      return prefix + parts.join("/");
+    };
+
+    /**
+     * Resolves the specified include path against the specified origin path.
+     * @param {string} originPath Path to the origin file
+     * @param {string} includePath Include path relative to origin path
+     * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
+     * @returns {string} Path to the include file
+     */
+    path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
+      if (!alreadyNormalized) includePath = normalize(includePath);
+      if (isAbsolute(includePath)) return includePath;
+      if (!alreadyNormalized) originPath = normalize(originPath);
+      return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
+    };
+  })(index.__exports);
+  return index.__exports;
+}
+
+exports.__require = requirePath;

package/dist/cjs/node_modules/@protobufjs/utf8/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('../../../_virtual/index11.js');
+var index = require('../../../_virtual/index30.js');
 
 var hasRequiredUtf8;
 function requireUtf8() {

package/dist/cjs/node_modules/@scure/base/lib/esm/index.js

@@ -0,0 +1,303 @@
+'use strict';
+
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array';
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr)) return false;
+  if (arr.length === 0) return true;
+  if (isString) {
+    return arr.every(item => typeof item === 'string');
+  } else {
+    return arr.every(item => Number.isSafeInteger(item));
+  }
+}
+// no abytes: seems to have 10% slowdown. Why?!
+function afn(input) {
+  if (typeof input !== 'function') throw new Error('function expected');
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== 'string') throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n)) throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input)) throw new Error('array expected');
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input)) throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input)) throw new Error(`${label}: array of numbers expected`);
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function chain() {
+  const id = a => a;
+  // Wrap call in closure so JIT can inline calls
+  const wrap = (a, b) => c => a(b(c));
+  // Construct chain of args[-1].encode(args[-2].encode([...]))
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  const encode = args.map(x => x.encode).reduceRight(wrap, id);
+  // Construct chain of args[0].decode(args[1].decode(...))
+  const decode = args.map(x => x.decode).reduce(wrap, id);
+  return {
+    encode,
+    decode
+  };
+}
+/**
+ * Encodes integer radix representation to array of strings using alphabet and back.
+ * Could also be array of strings.
+ * @__NO_SIDE_EFFECTS__
+ */
+function alphabet(letters) {
+  // mapping 1 to "b"
+  const lettersA = typeof letters === 'string' ? letters.split('') : letters;
+  const len = lettersA.length;
+  astrArr('alphabet', lettersA);
+  // mapping "b" to 1
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: digits => {
+      aArr(digits);
+      return digits.map(i => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len) throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: input => {
+      aArr(input);
+      return input.map(letter => {
+        astr('alphabet.decode', letter);
+        const i = indexes.get(letter);
+        if (i === undefined) throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function join() {
+  let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  astr('join', separator);
+  return {
+    encode: from => {
+      astrArr('join.decode', from);
+      return from.join(separator);
+    },
+    decode: to => {
+      astr('join.decode', to);
+      return to.split(separator);
+    }
+  };
+}
+/**
+ * Pad strings array so it has integer number of bits
+ * @__NO_SIDE_EFFECTS__
+ */
+function padding(bits) {
+  let chr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '=';
+  anumber(bits);
+  astr('padding', chr);
+  return {
+    encode(data) {
+      astrArr('padding.encode', data);
+      while (data.length * bits % 8) data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr('padding.decode', input);
+      let end = input.length;
+      if (end * bits % 8) throw new Error('padding: invalid, string should have whole number of bytes');
+      for (; end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0) throw new Error('padding: invalid, string has too much padding');
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+/**
+ * Slow: O(n^2) time complexity
+ */
+function convertRadix(data, from, to) {
+  // base 1 is impossible
+  if (from < 2) throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2) throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length) return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, d => {
+    anumber(d);
+    if (d < 0 || d >= from) throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error('convertRadix: carry overflow');
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase) throw new Error('convertRadix: carry overflow');
+      if (!done) continue;else if (!rounded) pos = i;else done = false;
+    }
+    res.push(carry);
+    if (done) break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++) res.push(0);
+  return res.reverse();
+}
+const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+const radix2carry = /* @__NO_SIDE_EFFECTS__ */(from, to) => from + (to - gcd(from, to));
+const powers = /* @__PURE__ */(() => {
+  let res = [];
+  for (let i = 0; i < 40; i++) res.push(2 ** i);
+  return res;
+})();
+/**
+ * Implemented with numbers, because BigInt is 5x slower
+ */
+function convertRadix2(data, from, to, padding) {
+  aArr(data);
+  if (from <= 0 || from > 32) throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32) throw new Error(`convertRadix2: wrong to=${to}`);
+  if (radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0; // bitwise position in current element
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max) throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32) throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to) res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === undefined) throw new Error('invalid carry');
+    carry &= pow - 1; // clean carry, otherwise it will cause overflow
+  }
+  carry = carry << to - pos & mask;
+  if (!padding && pos >= from) throw new Error('Excess padding');
+  if (!padding && carry > 0) throw new Error(`Non-zero padding: ${carry}`);
+  if (padding && pos > 0) res.push(carry >>> 0);
+  return res;
+}
+/**
+ * @__NO_SIDE_EFFECTS__
+ */
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: bytes => {
+      if (!isBytes(bytes)) throw new Error('radix.encode input should be Uint8Array');
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: digits => {
+      anumArr('radix.decode', digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+/**
+ * If both bases are power of same number (like `2**8 <-> 2**64`),
+ * there is a linear algorithm. For now we have implementation for power-of-two bases only.
+ * @__NO_SIDE_EFFECTS__
+ */
+function radix2(bits) {
+  let revPadding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  anumber(bits);
+  if (bits <= 0 || bits > 32) throw new Error('radix2: bits should be in (0..32]');
+  if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32) throw new Error('radix2: carry overflow');
+  return {
+    encode: bytes => {
+      if (!isBytes(bytes)) throw new Error('radix2.encode input should be Uint8Array');
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: digits => {
+      anumArr('radix2.decode', digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function checksum(len, fn) {
+  anumber(len);
+  afn(fn);
+  return {
+    encode(data) {
+      if (!isBytes(data)) throw new Error('checksum.encode: input should be Uint8Array');
+      const sum = fn(data).slice(0, len);
+      const res = new Uint8Array(data.length + len);
+      res.set(data);
+      res.set(sum, data.length);
+      return res;
+    },
+    decode(data) {
+      if (!isBytes(data)) throw new Error('checksum.decode: input should be Uint8Array');
+      const payload = data.slice(0, -len);
+      const oldChecksum = data.slice(-len);
+      const newChecksum = fn(payload).slice(0, len);
+      for (let i = 0; i < len; i++) if (newChecksum[i] !== oldChecksum[i]) throw new Error('Invalid checksum');
+      return payload;
+    }
+  };
+}
+// prettier-ignore
+const utils = {
+  alphabet,
+  chain,
+  checksum,
+  convertRadix,
+  convertRadix2,
+  radix,
+  radix2,
+  join,
+  padding
+};
+// base58 code
+// -----------
+const genBase58 = /* @__NO_SIDE_EFFECTS__ */abc => chain(radix(58), alphabet(abc), join(''));
+/**
+ * base58: base64 without ambigous characters +, /, 0, O, I, l.
+ * Quadratic (O(n^2)) - so, can't be used on large inputs.
+ * @example
+ * ```js
+ * base58.decode('01abcdef');
+ * // => '3UhJW'
+ * ```
+ */
+const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+/**
+ * Method, which creates base58check encoder.
+ * Requires function, calculating sha256.
+ */
+const createBase58check = sha256 => chain(checksum(4, data => sha256(sha256(data))), base58);
+
+exports.base58 = base58;
+exports.createBase58check = createBase58check;
+exports.utils = utils;

package/dist/cjs/node_modules/@scure/bip32/lib/esm/index.js

@@ -0,0 +1,293 @@
+'use strict';
+
+var modular = require('../../../../@noble/curves/esm/abstract/modular.js');
+var secp256k1 = require('../../../../@noble/curves/esm/secp256k1.js');
+var hmac = require('../../../../@noble/hashes/esm/hmac.js');
+var legacy = require('../../../../@noble/hashes/esm/legacy.js');
+var sha2 = require('../../../../@noble/hashes/esm/sha2.js');
+var utils = require('../../../../@noble/hashes/esm/utils.js');
+var index = require('../../../base/lib/esm/index.js');
+
+/**
+ * @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 Point = secp256k1.secp256k1.ProjectivePoint;
+const base58check = index.createBase58check(sha2.sha256);
+function bytesToNumber(bytes) {
+  utils.abytes(bytes);
+  const h = bytes.length === 0 ? '0' : utils.bytesToHex(bytes);
+  return BigInt('0x' + h);
+}
+function numberToBytes(num) {
+  if (typeof num !== 'bigint') throw new Error('bigint expected');
+  return utils.hexToBytes(num.toString(16).padStart(64, '0'));
+}
+const MASTER_SECRET = utils.utf8ToBytes('Bitcoin seed');
+// Bitcoin hardcoded by default
+const BITCOIN_VERSIONS = {
+  private: 0x0488ade4,
+  public: 0x0488b21e
+};
+const HARDENED_OFFSET = 0x80000000;
+const hash160 = data => legacy.ripemd160(sha2.sha256(data));
+const fromU32 = data => utils.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);
+  utils.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, utils.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) {
+    let versions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : BITCOIN_VERSIONS;
+    utils.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.hmac(sha2.sha512, MASTER_SECRET, seed);
+    return new HDKey({
+      versions,
+      chainCode: I.slice(32),
+      privateKey: I.slice(0, 32)
+    });
+  }
+  static fromExtendedKey(base58key) {
+    let versions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : BITCOIN_VERSIONS;
+    // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+    const keyBuffer = base58check.decode(base58key);
+    const keyView = utils.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.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.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 >= 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 = utils.concatBytes(new Uint8Array([0]), priv, data);
+    } else {
+      // Normal child: serP(point(kpar)) || ser32(index)
+      data = utils.concatBytes(this.pubKey, data);
+    }
+    const I = hmac.hmac(sha2.sha512, this.chainCode, data);
+    const childTweak = bytesToNumber(I.slice(0, 32));
+    const chainCode = I.slice(32);
+    if (!secp256k1.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 = modular.mod(this.privKey + childTweak, secp256k1.secp256k1.CURVE.n);
+        if (!secp256k1.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!');
+    }
+    utils.abytes(hash, 32);
+    return secp256k1.secp256k1.sign(hash, this.privKey).toCompactRawBytes();
+  }
+  verify(hash, signature) {
+    utils.abytes(hash, 32);
+    utils.abytes(signature, 64);
+    if (!this.publicKey) {
+      throw new Error('No publicKey set!');
+    }
+    let sig;
+    try {
+      sig = secp256k1.secp256k1.Signature.fromCompact(signature);
+    } catch (error) {
+      return false;
+    }
+    return secp256k1.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');
+    }
+    utils.abytes(key, 33);
+    // version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+    return utils.concatBytes(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+  }
+}
+
+exports.HARDENED_OFFSET = HARDENED_OFFSET;
+exports.HDKey = HDKey;