@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/nist-Cie-30E0.js

@@ -0,0 +1,40 @@
+import { s as sha256 } from './sha2-OXpLEvj4.js';
+import { e as ecdsa, w as weierstrass } from './weierstrass-CDW51Eto.js';
+
+/**
+ * Internal module for NIST P256, P384, P521 curves.
+ * Do not use for now.
+ * @module
+ */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// p = 2n**224n * (2n**32n-1n) + 2n**192n + 2n**96n - 1n
+// a = Fp256.create(BigInt('-3'));
+const p256_CURVE = /* @__PURE__ */ (() => ({
+    p: BigInt('0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff'),
+    n: BigInt('0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551'),
+    h: BigInt(1),
+    a: BigInt('0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc'),
+    b: BigInt('0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b'),
+    Gx: BigInt('0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296'),
+    Gy: BigInt('0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5'),
+}))();
+// NIST P256
+const p256_Point = /* @__PURE__ */ weierstrass(p256_CURVE);
+/**
+ * NIST P256 (aka secp256r1, prime256v1) curve, ECDSA and ECDH methods.
+ * Hashes inputs with sha256 by default.
+ *
+ * @example
+ * ```js
+ * import { p256 } from '@noble/curves/nist.js';
+ * const { secretKey, publicKey } = p256.keygen();
+ * // const publicKey = p256.getPublicKey(secretKey);
+ * const msg = new TextEncoder().encode('hello noble');
+ * const sig = p256.sign(msg, secretKey);
+ * const isValid = p256.verify(sig, msg, publicKey);
+ * // const sigKeccak = p256.sign(keccak256(msg), secretKey, { prehash: false });
+ * ```
+ */
+const p256 = /* @__PURE__ */ ecdsa(p256_Point, sha256);
+
+export { p256 as p };

package/build/browser/p2pkh-CQ-LA34f.js

@@ -0,0 +1,136 @@
+import { a as parse, b as bitcoin, c as prop, d as compare, O as OPS$1, h as hash160, n as isCanonicalScriptSignature, m as isPoint, v as value, g as partial, o as object, B as BufferSchema, H as Hash160bitSchema, q as custom, N as NBufferSchemaFactory, k as string, r as readUInt8, e as decompile, w as writeUInt8, l as compile } from './prefix-config.type-BP_PoMwo.js';
+import { b as bs58check } from './index-BHlS2yKt.js';
+
+const OPS = OPS$1;
+// input: {signature} {pubkey}
+// output: OP_DUP OP_HASH160 {hash160(pubkey)} OP_EQUALVERIFY OP_CHECKSIG
+/**
+ * Creates a Pay-to-Public-Key-Hash (P2PKH) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2PKH payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+function p2pkh(a, opts) {
+  if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input)
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  parse(
+    partial(
+      object({
+        network: object({}),
+        address: string(),
+        hash: Hash160bitSchema,
+        output: NBufferSchemaFactory(25),
+        pubkey: custom(isPoint),
+        signature: custom(isCanonicalScriptSignature),
+        input: BufferSchema,
+      }),
+    ),
+    a,
+  );
+  const _address = value(() => {
+    const payload = bs58check.decode(a.address);
+    const version = readUInt8(payload, 0);
+    const hash = payload.slice(1);
+    return { version, hash };
+  });
+  const _chunks = value(() => {
+    return decompile(a.input);
+  });
+  const network = a.network || bitcoin;
+  const o = { name: 'p2pkh', network };
+  prop(o, 'address', () => {
+    if (!o.hash) return;
+    const payload = new Uint8Array(21);
+    writeUInt8(payload, 0, network.pubKeyHash);
+    payload.set(o.hash, 1);
+    return bs58check.encode(payload);
+  });
+  prop(o, 'hash', () => {
+    if (a.output) return a.output.slice(3, 23);
+    if (a.address) return _address().hash;
+    if (a.pubkey || o.pubkey) return hash160(a.pubkey || o.pubkey);
+  });
+  prop(o, 'output', () => {
+    if (!o.hash) return;
+    return compile([
+      OPS.OP_DUP,
+      OPS.OP_HASH160,
+      o.hash,
+      OPS.OP_EQUALVERIFY,
+      OPS.OP_CHECKSIG,
+    ]);
+  });
+  prop(o, 'pubkey', () => {
+    if (!a.input) return;
+    return _chunks()[1];
+  });
+  prop(o, 'signature', () => {
+    if (!a.input) return;
+    return _chunks()[0];
+  });
+  prop(o, 'input', () => {
+    if (!a.pubkey) return;
+    if (!a.signature) return;
+    return compile([a.signature, a.pubkey]);
+  });
+  prop(o, 'witness', () => {
+    if (!o.input) return;
+    return [];
+  });
+  // extended validation
+  if (opts.validate) {
+    let hash = Uint8Array.from([]);
+    if (a.address) {
+      if (_address().version !== network.pubKeyHash)
+        throw new TypeError('Invalid version or Network mismatch');
+      if (_address().hash.length !== 20) throw new TypeError('Invalid address');
+      hash = _address().hash;
+    }
+    if (a.hash) {
+      if (hash.length > 0 && compare(hash, a.hash) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = a.hash;
+    }
+    if (a.output) {
+      if (
+        a.output.length !== 25 ||
+        a.output[0] !== OPS.OP_DUP ||
+        a.output[1] !== OPS.OP_HASH160 ||
+        a.output[2] !== 0x14 ||
+        a.output[23] !== OPS.OP_EQUALVERIFY ||
+        a.output[24] !== OPS.OP_CHECKSIG
+      )
+        throw new TypeError('Output is invalid');
+      const hash2 = a.output.slice(3, 23);
+      if (hash.length > 0 && compare(hash, hash2) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = hash2;
+    }
+    if (a.pubkey) {
+      const pkh = hash160(a.pubkey);
+      if (hash.length > 0 && compare(hash, pkh) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = pkh;
+    }
+    if (a.input) {
+      const chunks = _chunks();
+      if (chunks.length !== 2) throw new TypeError('Input is invalid');
+      if (!isCanonicalScriptSignature(chunks[0]))
+        throw new TypeError('Input has invalid signature');
+      if (!isPoint(chunks[1])) throw new TypeError('Input has invalid pubkey');
+      if (a.signature && compare(a.signature, chunks[0]) !== 0)
+        throw new TypeError('Signature mismatch');
+      if (a.pubkey && compare(a.pubkey, chunks[1]) !== 0)
+        throw new TypeError('Pubkey mismatch');
+      const pkh = hash160(chunks[1]);
+      if (hash.length > 0 && compare(hash, pkh) !== 0)
+        throw new TypeError('Hash mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}
+
+export { p2pkh as p };

package/build/browser/p2sh-DAS7N8JO.js

@@ -0,0 +1,198 @@
+import { a as parse, b as bitcoin, c as prop, d as compare, O as OPS$1, s as stacksEqual, v as value, e as decompile, f as countNonPushOnlyOPs, h as hash160, i as isPushOnly, g as partial, o as object, B as BufferSchema, j as array, N as NBufferSchemaFactory, k as string, r as readUInt8, l as compile, w as writeUInt8 } from './prefix-config.type-BP_PoMwo.js';
+import { b as bs58check } from './index-BHlS2yKt.js';
+
+const OPS = OPS$1;
+// input: [redeemScriptSig ...] {redeemScript}
+// witness: <?>
+// output: OP_HASH160 {hash160(redeemScript)} OP_EQUAL
+/**
+ * Creates a Pay-to-Script-Hash (P2SH) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2SH payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+function p2sh(a, opts) {
+  if (!a.address && !a.hash && !a.output && !a.redeem && !a.input)
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  parse(
+    partial(
+      object({
+        network: object({}),
+        address: string(),
+        hash: NBufferSchemaFactory(20),
+        output: NBufferSchemaFactory(23),
+        redeem: partial(
+          object({
+            network: object({}),
+            output: BufferSchema,
+            input: BufferSchema,
+            witness: array(BufferSchema),
+          }),
+        ),
+        input: BufferSchema,
+        witness: array(BufferSchema),
+      }),
+    ),
+    a,
+  );
+  let network = a.network;
+  if (!network) {
+    network = (a.redeem && a.redeem.network) || bitcoin;
+  }
+  const o = { network };
+  const _address = value(() => {
+    const payload = bs58check.decode(a.address);
+    const version = readUInt8(payload, 0);
+    const hash = payload.slice(1);
+    return { version, hash };
+  });
+  const _chunks = value(() => {
+    return decompile(a.input);
+  });
+  const _redeem = value(() => {
+    const chunks = _chunks();
+    const lastChunk = chunks[chunks.length - 1];
+    return {
+      network,
+      output: lastChunk === OPS.OP_FALSE ? Uint8Array.from([]) : lastChunk,
+      input: compile(chunks.slice(0, -1)),
+      witness: a.witness || [],
+    };
+  });
+  // output dependents
+  prop(o, 'address', () => {
+    if (!o.hash) return;
+    const payload = new Uint8Array(21);
+    writeUInt8(payload, 0, o.network.scriptHash);
+    payload.set(o.hash, 1);
+    return bs58check.encode(payload);
+  });
+  prop(o, 'hash', () => {
+    // in order of least effort
+    if (a.output) return a.output.slice(2, 22);
+    if (a.address) return _address().hash;
+    if (o.redeem && o.redeem.output) return hash160(o.redeem.output);
+  });
+  prop(o, 'output', () => {
+    if (!o.hash) return;
+    return compile([OPS.OP_HASH160, o.hash, OPS.OP_EQUAL]);
+  });
+  // input dependents
+  prop(o, 'redeem', () => {
+    if (!a.input) return;
+    return _redeem();
+  });
+  prop(o, 'input', () => {
+    if (!a.redeem || !a.redeem.input || !a.redeem.output) return;
+    return compile(
+      [].concat(decompile(a.redeem.input), a.redeem.output),
+    );
+  });
+  prop(o, 'witness', () => {
+    if (o.redeem && o.redeem.witness) return o.redeem.witness;
+    if (o.input) return [];
+  });
+  prop(o, 'name', () => {
+    const nameParts = ['p2sh'];
+    if (o.redeem !== undefined && o.redeem.name !== undefined)
+      nameParts.push(o.redeem.name);
+    return nameParts.join('-');
+  });
+  if (opts.validate) {
+    let hash = Uint8Array.from([]);
+    if (a.address) {
+      if (_address().version !== network.scriptHash)
+        throw new TypeError('Invalid version or Network mismatch');
+      if (_address().hash.length !== 20) throw new TypeError('Invalid address');
+      hash = _address().hash;
+    }
+    if (a.hash) {
+      if (hash.length > 0 && compare(hash, a.hash) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = a.hash;
+    }
+    if (a.output) {
+      if (
+        a.output.length !== 23 ||
+        a.output[0] !== OPS.OP_HASH160 ||
+        a.output[1] !== 0x14 ||
+        a.output[22] !== OPS.OP_EQUAL
+      )
+        throw new TypeError('Output is invalid');
+      const hash2 = a.output.slice(2, 22);
+      if (hash.length > 0 && compare(hash, hash2) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = hash2;
+    }
+    // inlined to prevent 'no-inner-declarations' failing
+    const checkRedeem = redeem => {
+      // is the redeem output empty/invalid?
+      if (redeem.output) {
+        const decompile$1 = decompile(redeem.output);
+        if (!decompile$1 || decompile$1.length < 1)
+          throw new TypeError('Redeem.output too short');
+        if (redeem.output.byteLength > 520)
+          throw new TypeError(
+            'Redeem.output unspendable if larger than 520 bytes',
+          );
+        if (countNonPushOnlyOPs(decompile$1) > 201)
+          throw new TypeError(
+            'Redeem.output unspendable with more than 201 non-push ops',
+          );
+        // match hash against other sources
+        const hash2 = hash160(redeem.output);
+        if (hash.length > 0 && compare(hash, hash2) !== 0)
+          throw new TypeError('Hash mismatch');
+        else hash = hash2;
+      }
+      if (redeem.input) {
+        const hasInput = redeem.input.length > 0;
+        const hasWitness = redeem.witness && redeem.witness.length > 0;
+        if (!hasInput && !hasWitness) throw new TypeError('Empty input');
+        if (hasInput && hasWitness)
+          throw new TypeError('Input and witness provided');
+        if (hasInput) {
+          const richunks = decompile(redeem.input);
+          if (!isPushOnly(richunks))
+            throw new TypeError('Non push-only scriptSig');
+        }
+      }
+    };
+    if (a.input) {
+      const chunks = _chunks();
+      if (!chunks || chunks.length < 1) throw new TypeError('Input too short');
+      if (!(_redeem().output instanceof Uint8Array))
+        throw new TypeError('Input is invalid');
+      checkRedeem(_redeem());
+    }
+    if (a.redeem) {
+      if (a.redeem.network && a.redeem.network !== network)
+        throw new TypeError('Network mismatch');
+      if (a.input) {
+        const redeem = _redeem();
+        if (
+          a.redeem.output &&
+          compare(a.redeem.output, redeem.output) !== 0
+        )
+          throw new TypeError('Redeem.output mismatch');
+        if (a.redeem.input && compare(a.redeem.input, redeem.input) !== 0)
+          throw new TypeError('Redeem.input mismatch');
+      }
+      checkRedeem(a.redeem);
+    }
+    if (a.witness) {
+      if (
+        a.redeem &&
+        a.redeem.witness &&
+        !stacksEqual(a.redeem.witness, a.witness)
+      )
+        throw new TypeError('Witness and redeem.witness mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}
+
+export { p2sh as p };

package/build/browser/p2wpkh-g2Ewuefe.js

@@ -0,0 +1,135 @@
+import { a as parse, b as bitcoin, c as prop, d as compare, O as OPS$1, h as hash160, m as isPoint, n as isCanonicalScriptSignature, v as value, g as partial, o as object, j as array, B as BufferSchema, q as custom, N as NBufferSchemaFactory, k as string, t as distExports, l as compile } from './prefix-config.type-BP_PoMwo.js';
+
+const OPS = OPS$1;
+const EMPTY_BUFFER = new Uint8Array(0);
+// witness: {signature} {pubKey}
+// input: <>
+// output: OP_0 {pubKeyHash}
+/**
+ * Creates a pay-to-witness-public-key-hash (p2wpkh) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The p2wpkh payment object.
+ * @throws {TypeError} If the required data is missing or invalid.
+ */
+function p2wpkh(a, opts) {
+  if (!a.address && !a.hash && !a.output && !a.pubkey && !a.witness)
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  parse(
+    partial(
+      object({
+        address: string(),
+        hash: NBufferSchemaFactory(20),
+        input: NBufferSchemaFactory(0),
+        network: object({}),
+        output: NBufferSchemaFactory(22),
+        pubkey: custom(isPoint, 'Not a valid pubkey'),
+        signature: custom(isCanonicalScriptSignature),
+        witness: array(BufferSchema),
+      }),
+    ),
+    a,
+  );
+  const _address = value(() => {
+    const result = distExports.bech32.decode(a.address);
+    const version = result.words.shift();
+    const data = distExports.bech32.fromWords(result.words);
+    return {
+      version,
+      prefix: result.prefix,
+      data: Uint8Array.from(data),
+    };
+  });
+  const network = a.network || bitcoin;
+  const o = { name: 'p2wpkh', network };
+  prop(o, 'address', () => {
+    if (!o.hash) return;
+    const words = distExports.bech32.toWords(o.hash);
+    words.unshift(0x00);
+    return distExports.bech32.encode(network.bech32, words);
+  });
+  prop(o, 'hash', () => {
+    if (a.output) return a.output.slice(2, 22);
+    if (a.address) return _address().data;
+    if (a.pubkey || o.pubkey) return hash160(a.pubkey || o.pubkey);
+  });
+  prop(o, 'output', () => {
+    if (!o.hash) return;
+    return compile([OPS.OP_0, o.hash]);
+  });
+  prop(o, 'pubkey', () => {
+    if (a.pubkey) return a.pubkey;
+    if (!a.witness) return;
+    return a.witness[1];
+  });
+  prop(o, 'signature', () => {
+    if (!a.witness) return;
+    return a.witness[0];
+  });
+  prop(o, 'input', () => {
+    if (!o.witness) return;
+    return EMPTY_BUFFER;
+  });
+  prop(o, 'witness', () => {
+    if (!a.pubkey) return;
+    if (!a.signature) return;
+    return [a.signature, a.pubkey];
+  });
+  // extended validation
+  if (opts.validate) {
+    let hash = Uint8Array.from([]);
+    if (a.address) {
+      if (network && network.bech32 !== _address().prefix)
+        throw new TypeError('Invalid prefix or Network mismatch');
+      if (_address().version !== 0x00)
+        throw new TypeError('Invalid address version');
+      if (_address().data.length !== 20)
+        throw new TypeError('Invalid address data');
+      hash = _address().data;
+    }
+    if (a.hash) {
+      if (hash.length > 0 && compare(hash, a.hash) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = a.hash;
+    }
+    if (a.output) {
+      if (
+        a.output.length !== 22 ||
+        a.output[0] !== OPS.OP_0 ||
+        a.output[1] !== 0x14
+      )
+        throw new TypeError('Output is invalid');
+      if (hash.length > 0 && compare(hash, a.output.slice(2)) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = a.output.slice(2);
+    }
+    if (a.pubkey) {
+      const pkh = hash160(a.pubkey);
+      if (hash.length > 0 && compare(hash, pkh) !== 0)
+        throw new TypeError('Hash mismatch');
+      else hash = pkh;
+      if (!isPoint(a.pubkey) || a.pubkey.length !== 33)
+        throw new TypeError('Invalid pubkey for p2wpkh');
+    }
+    if (a.witness) {
+      if (a.witness.length !== 2) throw new TypeError('Witness is invalid');
+      if (!isCanonicalScriptSignature(a.witness[0]))
+        throw new TypeError('Witness has invalid signature');
+      if (!isPoint(a.witness[1]) || a.witness[1].length !== 33)
+        throw new TypeError('Witness has invalid pubkey');
+      if (a.signature && compare(a.signature, a.witness[0]) !== 0)
+        throw new TypeError('Signature mismatch');
+      // if (a.pubkey && !a.pubkey.equals(a.witness[1]))
+      if (a.pubkey && compare(a.pubkey, a.witness[1]) !== 0)
+        throw new TypeError('Pubkey mismatch');
+      const pkh = hash160(a.witness[1]);
+      if (hash.length > 0 && compare(hash, pkh) !== 0)
+        throw new TypeError('Hash mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}
+
+export { p2wpkh as p };