bitcoin-main-lib 0.0.1-security → 7.1.6

package/src/cjs/payments/embed.cjs

@@ -0,0 +1,97 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2data = p2data;
+const networks_js_1 = require('../networks.cjs');
+const bscript = __importStar(require('../script.cjs'));
+const types_js_1 = require('../types.cjs');
+const lazy = __importStar(require('./lazy.cjs'));
+const v = __importStar(require('valibot'));
+const OPS = bscript.OPS;
+// output: OP_RETURN ...
+/**
+ * Embeds data in a Bitcoin payment.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The modified payment object.
+ * @throws {TypeError} If there is not enough data or if the output is invalid.
+ */
+function p2data(a, opts) {
+  if (!a.data && !a.output) throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  v.parse(
+    v.partial(
+      v.object({
+        network: v.object({}),
+        output: types_js_1.BufferSchema,
+        data: v.array(types_js_1.BufferSchema),
+      }),
+    ),
+    a,
+  );
+  const network = a.network || networks_js_1.bitcoin;
+  const o = { name: 'embed', network };
+  lazy.prop(o, 'output', () => {
+    if (!a.data) return;
+    return bscript.compile([OPS.OP_RETURN].concat(a.data));
+  });
+  lazy.prop(o, 'data', () => {
+    if (!a.output) return;
+    return bscript.decompile(a.output).slice(1);
+  });
+  // extended validation
+  if (opts.validate) {
+    if (a.output) {
+      const chunks = bscript.decompile(a.output);
+      if (chunks[0] !== OPS.OP_RETURN) throw new TypeError('Output is invalid');
+      if (!chunks.slice(1).every(chunk => v.is(types_js_1.BufferSchema, chunk)))
+        throw new TypeError('Output is invalid');
+      if (a.data && !(0, types_js_1.stacksEqual)(a.data, o.data))
+        throw new TypeError('Data mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}

package/src/cjs/payments/embed.d.ts

@@ -0,0 +1,9 @@
+import { Payment, PaymentOpts } from './index.js';
+/**
+ * Embeds data in a Bitcoin payment.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The modified payment object.
+ * @throws {TypeError} If there is not enough data or if the output is invalid.
+ */
+export declare function p2data(a: Payment, opts?: PaymentOpts): Payment;

package/src/cjs/payments/index.cjs

@@ -0,0 +1,69 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2tr =
+  exports.p2wsh =
+  exports.p2wpkh =
+  exports.p2sh =
+  exports.p2pkh =
+  exports.p2pk =
+  exports.p2ms =
+  exports.embed =
+    void 0;
+const embed_js_1 = require('./embed.cjs');
+Object.defineProperty(exports, 'embed', {
+  enumerable: true,
+  get: function () {
+    return embed_js_1.p2data;
+  },
+});
+const p2ms_js_1 = require('./p2ms.cjs');
+Object.defineProperty(exports, 'p2ms', {
+  enumerable: true,
+  get: function () {
+    return p2ms_js_1.p2ms;
+  },
+});
+const p2pk_js_1 = require('./p2pk.cjs');
+Object.defineProperty(exports, 'p2pk', {
+  enumerable: true,
+  get: function () {
+    return p2pk_js_1.p2pk;
+  },
+});
+const p2pkh_js_1 = require('./p2pkh.cjs');
+Object.defineProperty(exports, 'p2pkh', {
+  enumerable: true,
+  get: function () {
+    return p2pkh_js_1.p2pkh;
+  },
+});
+const p2sh_js_1 = require('./p2sh.cjs');
+Object.defineProperty(exports, 'p2sh', {
+  enumerable: true,
+  get: function () {
+    return p2sh_js_1.p2sh;
+  },
+});
+const p2wpkh_js_1 = require('./p2wpkh.cjs');
+Object.defineProperty(exports, 'p2wpkh', {
+  enumerable: true,
+  get: function () {
+    return p2wpkh_js_1.p2wpkh;
+  },
+});
+const p2wsh_js_1 = require('./p2wsh.cjs');
+Object.defineProperty(exports, 'p2wsh', {
+  enumerable: true,
+  get: function () {
+    return p2wsh_js_1.p2wsh;
+  },
+});
+const p2tr_js_1 = require('./p2tr.cjs');
+Object.defineProperty(exports, 'p2tr', {
+  enumerable: true,
+  get: function () {
+    return p2tr_js_1.p2tr;
+  },
+});
+// TODO
+// witness commitment

package/src/cjs/payments/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Provides functionality for creating and managing Bitcoin payment objects.
+ *
+ * This module supports multiple Bitcoin address types for payments, including:
+ * - P2PKH (Pay-to-PubKey-Hash)
+ * - P2SH (Pay-to-Script-Hash)
+ * - P2WPKH (Pay-to-Witness-PubKey-Hash)
+ * - P2WSH (Pay-to-Witness-Script-Hash)
+ * - P2TR (Taproot)
+ *
+ * The `Payment` interface defines the structure of a payment object used for constructing various
+ * payment types, with fields for signatures, public keys, redeem scripts, and more.
+ *
+ * @packageDocumentation
+ */
+import { Network } from '../networks.js';
+import { Taptree } from '../types.js';
+import { p2data as embed } from './embed.js';
+import { p2ms } from './p2ms.js';
+import { p2pk } from './p2pk.js';
+import { p2pkh } from './p2pkh.js';
+import { p2sh } from './p2sh.js';
+import { p2wpkh } from './p2wpkh.js';
+import { p2wsh } from './p2wsh.js';
+import { p2tr } from './p2tr.js';
+export interface Payment {
+    name?: string;
+    network?: Network;
+    output?: Uint8Array;
+    data?: Uint8Array[];
+    m?: number;
+    n?: number;
+    pubkeys?: Uint8Array[];
+    input?: Uint8Array;
+    signatures?: Uint8Array[];
+    internalPubkey?: Uint8Array;
+    pubkey?: Uint8Array;
+    signature?: Uint8Array;
+    address?: string;
+    hash?: Uint8Array;
+    redeem?: Payment;
+    redeemVersion?: number;
+    scriptTree?: Taptree;
+    witness?: Uint8Array[];
+}
+export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
+export type PaymentFunction = () => Payment;
+export interface PaymentOpts {
+    validate?: boolean;
+    allowIncomplete?: boolean;
+}
+export type StackElement = Uint8Array | number;
+export type Stack = StackElement[];
+export type StackFunction = () => Stack;
+export { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh, p2tr };

package/src/cjs/payments/lazy.cjs

@@ -0,0 +1,31 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.prop = prop;
+exports.value = value;
+function prop(object, name, f) {
+  Object.defineProperty(object, name, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const _value = f.call(this);
+      this[name] = _value;
+      return _value;
+    },
+    set(_value) {
+      Object.defineProperty(this, name, {
+        configurable: true,
+        enumerable: true,
+        value: _value,
+        writable: true,
+      });
+    },
+  });
+}
+function value(f) {
+  let _value;
+  return () => {
+    if (_value !== undefined) return _value;
+    _value = f();
+    return _value;
+  };
+}

package/src/cjs/payments/lazy.d.ts

@@ -0,0 +1,2 @@
+export declare function prop(object: object, name: string, f: () => any): void;
+export declare function value<T>(f: () => T): () => T;

package/src/cjs/payments/p2ms.cjs

@@ -0,0 +1,220 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2ms = p2ms;
+const networks_js_1 = require('../networks.cjs');
+const bscript = __importStar(require('../script.cjs'));
+const scriptNumber = __importStar(require('../script_number.cjs'));
+const types_js_1 = require('../types.cjs');
+const lazy = __importStar(require('./lazy.cjs'));
+const v = __importStar(require('valibot'));
+const OPS = bscript.OPS;
+const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
+function encodeSmallOrScriptNum(n) {
+  return n <= 16 ? OP_INT_BASE + n : scriptNumber.encode(n);
+}
+function decodeSmallOrScriptNum(chunk) {
+  if (typeof chunk === 'number') {
+    const val = chunk - OP_INT_BASE;
+    if (val < 1 || val > 16)
+      throw new TypeError(`Invalid opcode: expected OP_1–OP_16, got ${chunk}`);
+    return val;
+  } else return scriptNumber.decode(chunk);
+}
+function isSmallOrScriptNum(chunk) {
+  if (typeof chunk === 'number')
+    return chunk - OP_INT_BASE >= 1 && chunk - OP_INT_BASE <= 16;
+  else return Number.isInteger(scriptNumber.decode(chunk));
+}
+// input: OP_0 [signatures ...]
+// output: m [pubKeys ...] n OP_CHECKMULTISIG
+/**
+ * Represents a function that creates a Pay-to-Multisig (P2MS) payment object.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The created payment object.
+ * @throws {TypeError} If the provided data is not valid.
+ */
+function p2ms(a, opts) {
+  if (
+    !a.input &&
+    !a.output &&
+    !(a.pubkeys && a.m !== undefined) &&
+    !a.signatures
+  )
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  function isAcceptableSignature(x) {
+    return (
+      bscript.isCanonicalScriptSignature(x) ||
+      (opts.allowIncomplete && x === OPS.OP_0) !== undefined
+    );
+  }
+  v.parse(
+    v.partial(
+      v.object({
+        network: v.object({}),
+        m: v.number(),
+        n: v.number(),
+        output: types_js_1.BufferSchema,
+        pubkeys: v.array(
+          v.custom(types_js_1.isPoint),
+          'Received invalid pubkey',
+        ),
+        signatures: v.array(
+          v.custom(isAcceptableSignature),
+          'Expected signature to be of type isAcceptableSignature',
+        ),
+        input: types_js_1.BufferSchema,
+      }),
+    ),
+    a,
+  );
+  const network = a.network || networks_js_1.bitcoin;
+  const o = { network };
+  let chunks = [];
+  let decoded = false;
+  function decode(output) {
+    if (decoded) return;
+    decoded = true;
+    chunks = bscript.decompile(output);
+    if (chunks.length < 3) throw new TypeError('Output is invalid');
+    o.m = decodeSmallOrScriptNum(chunks[0]);
+    o.n = decodeSmallOrScriptNum(chunks[chunks.length - 2]);
+    o.pubkeys = chunks.slice(1, -2);
+  }
+  lazy.prop(o, 'output', () => {
+    if (!a.m) return;
+    if (!o.n) return;
+    if (!a.pubkeys) return;
+    return bscript.compile(
+      [].concat(
+        encodeSmallOrScriptNum(a.m),
+        a.pubkeys,
+        encodeSmallOrScriptNum(o.n),
+        OPS.OP_CHECKMULTISIG,
+      ),
+    );
+  });
+  lazy.prop(o, 'm', () => {
+    if (!o.output) return;
+    decode(o.output);
+    return o.m;
+  });
+  lazy.prop(o, 'n', () => {
+    if (!o.pubkeys) return;
+    return o.pubkeys.length;
+  });
+  lazy.prop(o, 'pubkeys', () => {
+    if (!a.output) return;
+    decode(a.output);
+    return o.pubkeys;
+  });
+  lazy.prop(o, 'signatures', () => {
+    if (!a.input) return;
+    return bscript.decompile(a.input).slice(1);
+  });
+  lazy.prop(o, 'input', () => {
+    if (!a.signatures) return;
+    return bscript.compile([OPS.OP_0].concat(a.signatures));
+  });
+  lazy.prop(o, 'witness', () => {
+    if (!o.input) return;
+    return [];
+  });
+  lazy.prop(o, 'name', () => {
+    if (!o.m || !o.n) return;
+    return `p2ms(${o.m} of ${o.n})`;
+  });
+  // extended validation
+  if (opts.validate) {
+    if (a.output) {
+      decode(a.output);
+      if (!isSmallOrScriptNum(chunks[0]))
+        throw new TypeError('Output is invalid');
+      if (!isSmallOrScriptNum(chunks[chunks.length - 2]))
+        throw new TypeError('Output is invalid');
+      if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG)
+        throw new TypeError('Output is invalid');
+      if (o.m <= 0 || o.n > 20 || o.m > o.n || o.n !== chunks.length - 3)
+        throw new TypeError('Output is invalid');
+      if (!o.pubkeys.every(x => (0, types_js_1.isPoint)(x)))
+        throw new TypeError('Output is invalid');
+      if (a.m !== undefined && a.m !== o.m) throw new TypeError('m mismatch');
+      if (a.n !== undefined && a.n !== o.n) throw new TypeError('n mismatch');
+      if (a.pubkeys && !(0, types_js_1.stacksEqual)(a.pubkeys, o.pubkeys))
+        throw new TypeError('Pubkeys mismatch');
+    }
+    if (a.pubkeys) {
+      if (a.n !== undefined && a.n !== a.pubkeys.length)
+        throw new TypeError('Pubkey count mismatch');
+      o.n = a.pubkeys.length;
+      if (o.n < o.m) throw new TypeError('Pubkey count cannot be less than m');
+    }
+    if (a.signatures) {
+      if (a.signatures.length < o.m)
+        throw new TypeError('Not enough signatures provided');
+      if (a.signatures.length > o.m)
+        throw new TypeError('Too many signatures provided');
+    }
+    if (a.input) {
+      if (a.input[0] !== OPS.OP_0) throw new TypeError('Input is invalid');
+      if (
+        o.signatures.length === 0 ||
+        !o.signatures.every(isAcceptableSignature)
+      )
+        throw new TypeError('Input has invalid signature(s)');
+      if (
+        a.signatures &&
+        !(0, types_js_1.stacksEqual)(a.signatures, o.signatures)
+      )
+        throw new TypeError('Signature mismatch');
+      if (a.m !== undefined && a.m !== a.signatures.length)
+        throw new TypeError('Signature count mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}

package/src/cjs/payments/p2ms.d.ts

@@ -0,0 +1,9 @@
+import { Payment, PaymentOpts } from './index.js';
+/**
+ * Represents a function that creates a Pay-to-Multisig (P2MS) payment object.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The created payment object.
+ * @throws {TypeError} If the provided data is not valid.
+ */
+export declare function p2ms(a: Payment, opts?: PaymentOpts): Payment;

package/src/cjs/payments/p2pk.cjs

@@ -0,0 +1,130 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2pk = p2pk;
+const networks_js_1 = require('../networks.cjs');
+const bscript = __importStar(require('../script.cjs'));
+const types_js_1 = require('../types.cjs');
+const lazy = __importStar(require('./lazy.cjs'));
+const tools = __importStar(require('uint8array-tools'));
+const v = __importStar(require('valibot'));
+const OPS = bscript.OPS;
+// input: {signature}
+// output: {pubKey} OP_CHECKSIG
+/**
+ * Creates a pay-to-public-key (P2PK) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2PK payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+function p2pk(a, opts) {
+  if (!a.input && !a.output && !a.pubkey && !a.input && !a.signature)
+    throw new TypeError('Not enough data');
+  opts = Object.assign({ validate: true }, opts || {});
+  v.parse(
+    v.partial(
+      v.object({
+        network: v.object({}),
+        output: types_js_1.BufferSchema,
+        pubkey: v.custom(types_js_1.isPoint, 'invalid pubkey'),
+        signature: v.custom(
+          bscript.isCanonicalScriptSignature,
+          'Expected signature to be of type isCanonicalScriptSignature',
+        ),
+        input: types_js_1.BufferSchema,
+      }),
+    ),
+    a,
+  );
+  const _chunks = lazy.value(() => {
+    return bscript.decompile(a.input);
+  });
+  const network = a.network || networks_js_1.bitcoin;
+  const o = { name: 'p2pk', network };
+  lazy.prop(o, 'output', () => {
+    if (!a.pubkey) return;
+    return bscript.compile([a.pubkey, OPS.OP_CHECKSIG]);
+  });
+  lazy.prop(o, 'pubkey', () => {
+    if (!a.output) return;
+    return a.output.slice(1, -1);
+  });
+  lazy.prop(o, 'signature', () => {
+    if (!a.input) return;
+    return _chunks()[0];
+  });
+  lazy.prop(o, 'input', () => {
+    if (!a.signature) return;
+    return bscript.compile([a.signature]);
+  });
+  lazy.prop(o, 'witness', () => {
+    if (!o.input) return;
+    return [];
+  });
+  // extended validation
+  if (opts.validate) {
+    if (a.output) {
+      if (a.output[a.output.length - 1] !== OPS.OP_CHECKSIG)
+        throw new TypeError('Output is invalid');
+      if (!(0, types_js_1.isPoint)(o.pubkey))
+        throw new TypeError('Output pubkey is invalid');
+      if (a.pubkey && tools.compare(a.pubkey, o.pubkey) !== 0)
+        throw new TypeError('Pubkey mismatch');
+    }
+    if (a.signature) {
+      if (a.input && tools.compare(a.input, o.input) !== 0)
+        throw new TypeError('Signature mismatch');
+    }
+    if (a.input) {
+      if (_chunks().length !== 1) throw new TypeError('Input is invalid');
+      if (!bscript.isCanonicalScriptSignature(o.signature))
+        throw new TypeError('Input has invalid signature');
+    }
+  }
+  return Object.assign(o, a);
+}

package/src/cjs/payments/p2pk.d.ts

@@ -0,0 +1,10 @@
+import { Payment, PaymentOpts } from './index.js';
+/**
+ * Creates a pay-to-public-key (P2PK) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2PK payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+export declare function p2pk(a: Payment, opts?: PaymentOpts): Payment;