bitcoin-main-lib 0.0.1-security → 7.0.6

package/src/esm/networks.js

@@ -0,0 +1,66 @@
+/**
+ * Represents the Bitcoin network configuration.
+ */
+export const bitcoin = {
+  /**
+   * The message prefix used for signing Bitcoin messages.
+   */
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  /**
+   * The Bech32 prefix used for Bitcoin addresses.
+   */
+  bech32: 'bc',
+  /**
+   * The BIP32 key prefixes for Bitcoin.
+   */
+  bip32: {
+    /**
+     * The public key prefix for BIP32 extended public keys.
+     */
+    public: 0x0488b21e,
+    /**
+     * The private key prefix for BIP32 extended private keys.
+     */
+    private: 0x0488ade4,
+  },
+  /**
+   * The prefix for Bitcoin public key hashes.
+   */
+  pubKeyHash: 0x00,
+  /**
+   * The prefix for Bitcoin script hashes.
+   */
+  scriptHash: 0x05,
+  /**
+   * The prefix for Bitcoin Wallet Import Format (WIF) private keys.
+   */
+  wif: 0x80,
+};
+/**
+ * Represents the regtest network configuration.
+ */
+export const regtest = {
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'bcrt',
+  bip32: {
+    public: 0x043587cf,
+    private: 0x04358394,
+  },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};
+/**
+ * Represents the testnet network configuration.
+ */
+export const testnet = {
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'tb',
+  bip32: {
+    public: 0x043587cf,
+    private: 0x04358394,
+  },
+  pubKeyHash: 0x6f,
+  scriptHash: 0xc4,
+  wif: 0xef,
+};

package/src/esm/ops.js

@@ -0,0 +1,125 @@
+// Define OPS enum
+var OPS;
+(function (OPS) {
+  OPS[(OPS['OP_FALSE'] = 0)] = 'OP_FALSE';
+  OPS[(OPS['OP_0'] = 0)] = 'OP_0';
+  OPS[(OPS['OP_PUSHDATA1'] = 76)] = 'OP_PUSHDATA1';
+  OPS[(OPS['OP_PUSHDATA2'] = 77)] = 'OP_PUSHDATA2';
+  OPS[(OPS['OP_PUSHDATA4'] = 78)] = 'OP_PUSHDATA4';
+  OPS[(OPS['OP_1NEGATE'] = 79)] = 'OP_1NEGATE';
+  OPS[(OPS['OP_RESERVED'] = 80)] = 'OP_RESERVED';
+  OPS[(OPS['OP_TRUE'] = 81)] = 'OP_TRUE';
+  OPS[(OPS['OP_1'] = 81)] = 'OP_1';
+  OPS[(OPS['OP_2'] = 82)] = 'OP_2';
+  OPS[(OPS['OP_3'] = 83)] = 'OP_3';
+  OPS[(OPS['OP_4'] = 84)] = 'OP_4';
+  OPS[(OPS['OP_5'] = 85)] = 'OP_5';
+  OPS[(OPS['OP_6'] = 86)] = 'OP_6';
+  OPS[(OPS['OP_7'] = 87)] = 'OP_7';
+  OPS[(OPS['OP_8'] = 88)] = 'OP_8';
+  OPS[(OPS['OP_9'] = 89)] = 'OP_9';
+  OPS[(OPS['OP_10'] = 90)] = 'OP_10';
+  OPS[(OPS['OP_11'] = 91)] = 'OP_11';
+  OPS[(OPS['OP_12'] = 92)] = 'OP_12';
+  OPS[(OPS['OP_13'] = 93)] = 'OP_13';
+  OPS[(OPS['OP_14'] = 94)] = 'OP_14';
+  OPS[(OPS['OP_15'] = 95)] = 'OP_15';
+  OPS[(OPS['OP_16'] = 96)] = 'OP_16';
+  OPS[(OPS['OP_NOP'] = 97)] = 'OP_NOP';
+  OPS[(OPS['OP_VER'] = 98)] = 'OP_VER';
+  OPS[(OPS['OP_IF'] = 99)] = 'OP_IF';
+  OPS[(OPS['OP_NOTIF'] = 100)] = 'OP_NOTIF';
+  OPS[(OPS['OP_VERIF'] = 101)] = 'OP_VERIF';
+  OPS[(OPS['OP_VERNOTIF'] = 102)] = 'OP_VERNOTIF';
+  OPS[(OPS['OP_ELSE'] = 103)] = 'OP_ELSE';
+  OPS[(OPS['OP_ENDIF'] = 104)] = 'OP_ENDIF';
+  OPS[(OPS['OP_VERIFY'] = 105)] = 'OP_VERIFY';
+  OPS[(OPS['OP_RETURN'] = 106)] = 'OP_RETURN';
+  OPS[(OPS['OP_TOALTSTACK'] = 107)] = 'OP_TOALTSTACK';
+  OPS[(OPS['OP_FROMALTSTACK'] = 108)] = 'OP_FROMALTSTACK';
+  OPS[(OPS['OP_2DROP'] = 109)] = 'OP_2DROP';
+  OPS[(OPS['OP_2DUP'] = 110)] = 'OP_2DUP';
+  OPS[(OPS['OP_3DUP'] = 111)] = 'OP_3DUP';
+  OPS[(OPS['OP_2OVER'] = 112)] = 'OP_2OVER';
+  OPS[(OPS['OP_2ROT'] = 113)] = 'OP_2ROT';
+  OPS[(OPS['OP_2SWAP'] = 114)] = 'OP_2SWAP';
+  OPS[(OPS['OP_IFDUP'] = 115)] = 'OP_IFDUP';
+  OPS[(OPS['OP_DEPTH'] = 116)] = 'OP_DEPTH';
+  OPS[(OPS['OP_DROP'] = 117)] = 'OP_DROP';
+  OPS[(OPS['OP_DUP'] = 118)] = 'OP_DUP';
+  OPS[(OPS['OP_NIP'] = 119)] = 'OP_NIP';
+  OPS[(OPS['OP_OVER'] = 120)] = 'OP_OVER';
+  OPS[(OPS['OP_PICK'] = 121)] = 'OP_PICK';
+  OPS[(OPS['OP_ROLL'] = 122)] = 'OP_ROLL';
+  OPS[(OPS['OP_ROT'] = 123)] = 'OP_ROT';
+  OPS[(OPS['OP_SWAP'] = 124)] = 'OP_SWAP';
+  OPS[(OPS['OP_TUCK'] = 125)] = 'OP_TUCK';
+  OPS[(OPS['OP_CAT'] = 126)] = 'OP_CAT';
+  OPS[(OPS['OP_SUBSTR'] = 127)] = 'OP_SUBSTR';
+  OPS[(OPS['OP_LEFT'] = 128)] = 'OP_LEFT';
+  OPS[(OPS['OP_RIGHT'] = 129)] = 'OP_RIGHT';
+  OPS[(OPS['OP_SIZE'] = 130)] = 'OP_SIZE';
+  OPS[(OPS['OP_INVERT'] = 131)] = 'OP_INVERT';
+  OPS[(OPS['OP_AND'] = 132)] = 'OP_AND';
+  OPS[(OPS['OP_OR'] = 133)] = 'OP_OR';
+  OPS[(OPS['OP_XOR'] = 134)] = 'OP_XOR';
+  OPS[(OPS['OP_EQUAL'] = 135)] = 'OP_EQUAL';
+  OPS[(OPS['OP_EQUALVERIFY'] = 136)] = 'OP_EQUALVERIFY';
+  OPS[(OPS['OP_RESERVED1'] = 137)] = 'OP_RESERVED1';
+  OPS[(OPS['OP_RESERVED2'] = 138)] = 'OP_RESERVED2';
+  OPS[(OPS['OP_1ADD'] = 139)] = 'OP_1ADD';
+  OPS[(OPS['OP_1SUB'] = 140)] = 'OP_1SUB';
+  OPS[(OPS['OP_2MUL'] = 141)] = 'OP_2MUL';
+  OPS[(OPS['OP_2DIV'] = 142)] = 'OP_2DIV';
+  OPS[(OPS['OP_NEGATE'] = 143)] = 'OP_NEGATE';
+  OPS[(OPS['OP_ABS'] = 144)] = 'OP_ABS';
+  OPS[(OPS['OP_NOT'] = 145)] = 'OP_NOT';
+  OPS[(OPS['OP_0NOTEQUAL'] = 146)] = 'OP_0NOTEQUAL';
+  OPS[(OPS['OP_ADD'] = 147)] = 'OP_ADD';
+  OPS[(OPS['OP_SUB'] = 148)] = 'OP_SUB';
+  OPS[(OPS['OP_MUL'] = 149)] = 'OP_MUL';
+  OPS[(OPS['OP_DIV'] = 150)] = 'OP_DIV';
+  OPS[(OPS['OP_MOD'] = 151)] = 'OP_MOD';
+  OPS[(OPS['OP_LSHIFT'] = 152)] = 'OP_LSHIFT';
+  OPS[(OPS['OP_RSHIFT'] = 153)] = 'OP_RSHIFT';
+  OPS[(OPS['OP_BOOLAND'] = 154)] = 'OP_BOOLAND';
+  OPS[(OPS['OP_BOOLOR'] = 155)] = 'OP_BOOLOR';
+  OPS[(OPS['OP_NUMEQUAL'] = 156)] = 'OP_NUMEQUAL';
+  OPS[(OPS['OP_NUMEQUALVERIFY'] = 157)] = 'OP_NUMEQUALVERIFY';
+  OPS[(OPS['OP_NUMNOTEQUAL'] = 158)] = 'OP_NUMNOTEQUAL';
+  OPS[(OPS['OP_LESSTHAN'] = 159)] = 'OP_LESSTHAN';
+  OPS[(OPS['OP_GREATERTHAN'] = 160)] = 'OP_GREATERTHAN';
+  OPS[(OPS['OP_LESSTHANOREQUAL'] = 161)] = 'OP_LESSTHANOREQUAL';
+  OPS[(OPS['OP_GREATERTHANOREQUAL'] = 162)] = 'OP_GREATERTHANOREQUAL';
+  OPS[(OPS['OP_MIN'] = 163)] = 'OP_MIN';
+  OPS[(OPS['OP_MAX'] = 164)] = 'OP_MAX';
+  OPS[(OPS['OP_WITHIN'] = 165)] = 'OP_WITHIN';
+  OPS[(OPS['OP_RIPEMD160'] = 166)] = 'OP_RIPEMD160';
+  OPS[(OPS['OP_SHA1'] = 167)] = 'OP_SHA1';
+  OPS[(OPS['OP_SHA256'] = 168)] = 'OP_SHA256';
+  OPS[(OPS['OP_HASH160'] = 169)] = 'OP_HASH160';
+  OPS[(OPS['OP_HASH256'] = 170)] = 'OP_HASH256';
+  OPS[(OPS['OP_CODESEPARATOR'] = 171)] = 'OP_CODESEPARATOR';
+  OPS[(OPS['OP_CHECKSIG'] = 172)] = 'OP_CHECKSIG';
+  OPS[(OPS['OP_CHECKSIGVERIFY'] = 173)] = 'OP_CHECKSIGVERIFY';
+  OPS[(OPS['OP_CHECKMULTISIG'] = 174)] = 'OP_CHECKMULTISIG';
+  OPS[(OPS['OP_CHECKMULTISIGVERIFY'] = 175)] = 'OP_CHECKMULTISIGVERIFY';
+  OPS[(OPS['OP_NOP1'] = 176)] = 'OP_NOP1';
+  OPS[(OPS['OP_CHECKLOCKTIMEVERIFY'] = 177)] = 'OP_CHECKLOCKTIMEVERIFY';
+  OPS[(OPS['OP_NOP2'] = 177)] = 'OP_NOP2';
+  OPS[(OPS['OP_CHECKSEQUENCEVERIFY'] = 178)] = 'OP_CHECKSEQUENCEVERIFY';
+  OPS[(OPS['OP_NOP3'] = 178)] = 'OP_NOP3';
+  OPS[(OPS['OP_NOP4'] = 179)] = 'OP_NOP4';
+  OPS[(OPS['OP_NOP5'] = 180)] = 'OP_NOP5';
+  OPS[(OPS['OP_NOP6'] = 181)] = 'OP_NOP6';
+  OPS[(OPS['OP_NOP7'] = 182)] = 'OP_NOP7';
+  OPS[(OPS['OP_NOP8'] = 183)] = 'OP_NOP8';
+  OPS[(OPS['OP_NOP9'] = 184)] = 'OP_NOP9';
+  OPS[(OPS['OP_NOP10'] = 185)] = 'OP_NOP10';
+  OPS[(OPS['OP_CHECKSIGADD'] = 186)] = 'OP_CHECKSIGADD';
+  OPS[(OPS['OP_PUBKEYHASH'] = 253)] = 'OP_PUBKEYHASH';
+  OPS[(OPS['OP_PUBKEY'] = 254)] = 'OP_PUBKEY';
+  OPS[(OPS['OP_INVALIDOPCODE'] = 255)] = 'OP_INVALIDOPCODE';
+})(OPS || (OPS = {}));
+// Export modules
+export { OPS };

package/src/esm/payments/bip341.js

@@ -0,0 +1,135 @@
+import { getEccLib } from '../ecc_lib.js';
+import * as bcrypto from '../crypto.js';
+import { varuint } from '../bufferutils.js';
+import { isTapleaf } from '../types.js';
+import * as tools from 'uint8array-tools';
+export const LEAF_VERSION_TAPSCRIPT = 0xc0;
+export const MAX_TAPTREE_DEPTH = 128;
+const isHashBranch = ht => 'left' in ht && 'right' in ht;
+/**
+ * Calculates the root hash from a given control block and leaf hash.
+ * @param controlBlock - The control block buffer.
+ * @param leafHash - The leaf hash buffer.
+ * @returns The root hash buffer.
+ * @throws {TypeError} If the control block length is less than 33.
+ */
+export function rootHashFromPath(controlBlock, leafHash) {
+  if (controlBlock.length < 33)
+    throw new TypeError(
+      `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
+    );
+  const m = (controlBlock.length - 33) / 32;
+  let kj = leafHash;
+  for (let j = 0; j < m; j++) {
+    const ej = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
+    if (tools.compare(kj, ej) < 0) {
+      kj = tapBranchHash(kj, ej);
+    } else {
+      kj = tapBranchHash(ej, kj);
+    }
+  }
+  return kj;
+}
+/**
+ * Build a hash tree of merkle nodes from the scripts binary tree.
+ * @param scriptTree - the tree of scripts to pairwise hash.
+ */
+export function toHashTree(scriptTree) {
+  if (isTapleaf(scriptTree)) return { hash: tapleafHash(scriptTree) };
+  const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
+  // hashes.sort((a, b) => a.hash.compare(b.hash));
+  hashes.sort((a, b) => tools.compare(a.hash, b.hash));
+  const [left, right] = hashes;
+  return {
+    hash: tapBranchHash(left.hash, right.hash),
+    left,
+    right,
+  };
+}
+/**
+ * Given a HashTree, finds the path from a particular hash to the root.
+ * @param node - the root of the tree
+ * @param hash - the hash to search for
+ * @returns - array of sibling hashes, from leaf (inclusive) to root
+ * (exclusive) needed to prove inclusion of the specified hash. undefined if no
+ * path is found
+ */
+export function findScriptPath(node, hash) {
+  if (isHashBranch(node)) {
+    const leftPath = findScriptPath(node.left, hash);
+    if (leftPath !== undefined) return [...leftPath, node.right.hash];
+    const rightPath = findScriptPath(node.right, hash);
+    if (rightPath !== undefined) return [...rightPath, node.left.hash];
+  } else if (tools.compare(node.hash, hash) === 0) {
+    return [];
+  }
+  return undefined;
+}
+/**
+ * Calculates the tapleaf hash for a given Tapleaf object.
+ * @param leaf - The Tapleaf object to calculate the hash for.
+ * @returns The tapleaf hash as a Buffer.
+ */
+export function tapleafHash(leaf) {
+  const version = leaf.version || LEAF_VERSION_TAPSCRIPT;
+  return bcrypto.taggedHash(
+    'TapLeaf',
+    tools.concat([Uint8Array.from([version]), serializeScript(leaf.output)]),
+  );
+}
+/**
+ * Computes the taproot tweak hash for a given public key and optional hash.
+ * If a hash is provided, the public key and hash are concatenated before computing the hash.
+ * If no hash is provided, only the public key is used to compute the hash.
+ *
+ * @param pubKey - The public key buffer.
+ * @param h - The optional hash buffer.
+ * @returns The taproot tweak hash.
+ */
+export function tapTweakHash(pubKey, h) {
+  return bcrypto.taggedHash(
+    'TapTweak',
+    tools.concat(h ? [pubKey, h] : [pubKey]),
+  );
+}
+/**
+ * Tweak a public key with a given tweak hash.
+ * @param pubKey - The public key to be tweaked.
+ * @param h - The tweak hash.
+ * @returns The tweaked public key or null if the input is invalid.
+ */
+export function tweakKey(pubKey, h) {
+  if (!(pubKey instanceof Uint8Array)) return null;
+  if (pubKey.length !== 32) return null;
+  if (h && h.length !== 32) return null;
+  const tweakHash = tapTweakHash(pubKey, h);
+  const res = getEccLib().xOnlyPointAddTweak(pubKey, tweakHash);
+  if (!res || res.xOnlyPubkey === null) return null;
+  return {
+    parity: res.parity,
+    x: Uint8Array.from(res.xOnlyPubkey),
+  };
+}
+/**
+ * Computes the TapBranch hash by concatenating two buffers and applying the 'TapBranch' tagged hash algorithm.
+ *
+ * @param a - The first buffer.
+ * @param b - The second buffer.
+ * @returns The TapBranch hash of the concatenated buffers.
+ */
+function tapBranchHash(a, b) {
+  return bcrypto.taggedHash('TapBranch', tools.concat([a, b]));
+}
+/**
+ * Serializes a script by encoding its length as a varint and concatenating it with the script.
+ *
+ * @param s - The script to be serialized.
+ * @returns The serialized script as a Buffer.
+ */
+function serializeScript(s) {
+  /* global BigInt */
+  const varintLen = varuint.encodingLength(s.length);
+  const buffer = new Uint8Array(varintLen);
+  varuint.encode(s.length, buffer);
+  return tools.concat([buffer, s]);
+}

package/src/esm/payments/embed.js

@@ -0,0 +1,50 @@
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { stacksEqual, BufferSchema } from '../types.js';
+import * as lazy from './lazy.js';
+import * as v from '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.
+ */
+export 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: BufferSchema,
+        data: v.array(BufferSchema),
+      }),
+    ),
+    a,
+  );
+  const network = a.network || BITCOIN_NETWORK;
+  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(BufferSchema, chunk)))
+        throw new TypeError('Output is invalid');
+      if (a.data && !stacksEqual(a.data, o.data))
+        throw new TypeError('Data mismatch');
+    }
+  }
+  return Object.assign(o, a);
+}

package/src/esm/payments/index.js

@@ -0,0 +1,11 @@
+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 { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh, p2tr };
+// TODO
+// witness commitment

package/src/esm/payments/lazy.js

@@ -0,0 +1,27 @@
+export 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,
+      });
+    },
+  });
+}
+export function value(f) {
+  let _value;
+  return () => {
+    if (_value !== undefined) return _value;
+    _value = f();
+    return _value;
+  };
+}

package/src/esm/payments/p2ms.js

@@ -0,0 +1,167 @@
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import * as scriptNumber from '../script_number.js';
+import { BufferSchema, isPoint, stacksEqual } from '../types.js';
+import * as lazy from './lazy.js';
+import * as v from '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.
+ */
+export 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: BufferSchema,
+        pubkeys: v.array(v.custom(isPoint), 'Received invalid pubkey'),
+        signatures: v.array(
+          v.custom(isAcceptableSignature),
+          'Expected signature to be of type isAcceptableSignature',
+        ),
+        input: BufferSchema,
+      }),
+    ),
+    a,
+  );
+  const network = a.network || BITCOIN_NETWORK;
+  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 => 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 && !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 && !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/esm/payments/p2pk.js

@@ -0,0 +1,82 @@
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { BufferSchema, isPoint } from '../types.js';
+import * as lazy from './lazy.js';
+import * as tools from 'uint8array-tools';
+import * as v from '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.
+ */
+export 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: BufferSchema,
+        pubkey: v.custom(isPoint, 'invalid pubkey'),
+        signature: v.custom(
+          bscript.isCanonicalScriptSignature,
+          'Expected signature to be of type isCanonicalScriptSignature',
+        ),
+        input: BufferSchema,
+      }),
+    ),
+    a,
+  );
+  const _chunks = lazy.value(() => {
+    return bscript.decompile(a.input);
+  });
+  const network = a.network || BITCOIN_NETWORK;
+  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 (!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);
+}