@btc-vision/bitcoin 6.3.0

package/src/payments/embed.js

@@ -0,0 +1,54 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2data = void 0;
+const networks_1 = require('../networks');
+const bscript = require('../script');
+const types_1 = require('../types');
+const lazy = require('./lazy');
+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 || {});
+    (0, types_1.typeforce)(
+        {
+            network: types_1.typeforce.maybe(types_1.typeforce.Object),
+            output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+            data: types_1.typeforce.maybe(
+                types_1.typeforce.arrayOf(types_1.typeforce.Buffer),
+            ),
+        },
+        a,
+    );
+    const network = a.network || networks_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(types_1.typeforce.Buffer))
+                throw new TypeError('Output is invalid');
+            if (a.data && !(0, types_1.stacksEqual)(a.data, o.data))
+                throw new TypeError('Data mismatch');
+        }
+    }
+    return Object.assign(o, a);
+}
+exports.p2data = p2data;

package/src/payments/index.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+/**
+ * Represents a payment object, which is used to create a payment.
+ *
+ * Supports P2PKH、P2SH、P2WPKH、P2WSH、P2TR and so on
+ *
+ * @packageDocumentation
+ */
+import { Network } from '../networks';
+import { Taptree } from '../types';
+import { p2data as embed } from './embed';
+import { p2ms } from './p2ms';
+import { p2pk } from './p2pk';
+import { p2pkh } from './p2pkh';
+import { p2sh } from './p2sh';
+import { p2wpkh } from './p2wpkh';
+import { p2wsh } from './p2wsh';
+import { p2tr } from './p2tr';
+export interface Payment {
+    name?: string;
+    network?: Network;
+    output?: Buffer;
+    data?: Buffer[];
+    m?: number;
+    n?: number;
+    pubkeys?: Buffer[];
+    input?: Buffer;
+    signatures?: Buffer[];
+    internalPubkey?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+    address?: string;
+    hash?: Buffer;
+    redeem?: Payment;
+    redeemVersion?: number;
+    scriptTree?: Taptree;
+    witness?: Buffer[];
+}
+export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
+export type PaymentFunction = () => Payment;
+export interface PaymentOpts {
+    validate?: boolean;
+    allowIncomplete?: boolean;
+}
+export type StackElement = Buffer | number;
+export type Stack = StackElement[];
+export type StackFunction = () => Stack;
+export { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh, p2tr };

package/src/payments/index.js

@@ -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_1 = require('./embed');
+Object.defineProperty(exports, 'embed', {
+    enumerable: true,
+    get: function () {
+        return embed_1.p2data;
+    },
+});
+const p2ms_1 = require('./p2ms');
+Object.defineProperty(exports, 'p2ms', {
+    enumerable: true,
+    get: function () {
+        return p2ms_1.p2ms;
+    },
+});
+const p2pk_1 = require('./p2pk');
+Object.defineProperty(exports, 'p2pk', {
+    enumerable: true,
+    get: function () {
+        return p2pk_1.p2pk;
+    },
+});
+const p2pkh_1 = require('./p2pkh');
+Object.defineProperty(exports, 'p2pkh', {
+    enumerable: true,
+    get: function () {
+        return p2pkh_1.p2pkh;
+    },
+});
+const p2sh_1 = require('./p2sh');
+Object.defineProperty(exports, 'p2sh', {
+    enumerable: true,
+    get: function () {
+        return p2sh_1.p2sh;
+    },
+});
+const p2wpkh_1 = require('./p2wpkh');
+Object.defineProperty(exports, 'p2wpkh', {
+    enumerable: true,
+    get: function () {
+        return p2wpkh_1.p2wpkh;
+    },
+});
+const p2wsh_1 = require('./p2wsh');
+Object.defineProperty(exports, 'p2wsh', {
+    enumerable: true,
+    get: function () {
+        return p2wsh_1.p2wsh;
+    },
+});
+const p2tr_1 = require('./p2tr');
+Object.defineProperty(exports, 'p2tr', {
+    enumerable: true,
+    get: function () {
+        return p2tr_1.p2tr;
+    },
+});
+// TODO
+// witness commitment

package/src/payments/lazy.d.ts

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

package/src/payments/lazy.js

@@ -0,0 +1,32 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.value = exports.prop = void 0;
+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,
+            });
+        },
+    });
+}
+exports.prop = prop;
+function value(f) {
+    let _value;
+    return () => {
+        if (_value !== undefined) return _value;
+        _value = f();
+        return _value;
+    };
+}
+exports.value = value;

package/src/payments/p2ms.d.ts

@@ -0,0 +1,9 @@
+import { Payment, PaymentOpts } from './index';
+/**
+ * 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/payments/p2ms.js

@@ -0,0 +1,158 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2ms = void 0;
+const networks_1 = require('../networks');
+const bscript = require('../script');
+const types_1 = require('../types');
+const lazy = require('./lazy');
+const OPS = bscript.OPS;
+const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
+// 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
+        );
+    }
+    (0, types_1.typeforce)(
+        {
+            network: types_1.typeforce.maybe(types_1.typeforce.Object),
+            m: types_1.typeforce.maybe(types_1.typeforce.Number),
+            n: types_1.typeforce.maybe(types_1.typeforce.Number),
+            output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+            pubkeys: types_1.typeforce.maybe(
+                types_1.typeforce.arrayOf(types_1.isPoint),
+            ),
+            signatures: types_1.typeforce.maybe(
+                types_1.typeforce.arrayOf(isAcceptableSignature),
+            ),
+            input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+        },
+        a,
+    );
+    const network = a.network || networks_1.bitcoin;
+    const o = { network };
+    let chunks = [];
+    let decoded = false;
+    function decode(output) {
+        if (decoded) return;
+        decoded = true;
+        chunks = bscript.decompile(output);
+        o.m = chunks[0] - OP_INT_BASE;
+        o.n = chunks[chunks.length - 2] - OP_INT_BASE;
+        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(
+                OP_INT_BASE + a.m,
+                a.pubkeys,
+                OP_INT_BASE + 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 (!types_1.typeforce.Number(chunks[0]))
+                throw new TypeError('Output is invalid');
+            if (!types_1.typeforce.Number(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 > 16 || o.m > o.n || o.n !== chunks.length - 3)
+                throw new TypeError('Output is invalid');
+            if (!o.pubkeys.every(x => (0, types_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_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_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);
+}
+exports.p2ms = p2ms;

package/src/payments/p2pk.d.ts

@@ -0,0 +1,10 @@
+import { Payment, PaymentOpts } from './index';
+/**
+ * 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;

package/src/payments/p2pk.js

@@ -0,0 +1,82 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2pk = void 0;
+const networks_1 = require('../networks');
+const bscript = require('../script');
+const types_1 = require('../types');
+const lazy = require('./lazy');
+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 || {});
+    (0, types_1.typeforce)(
+        {
+            network: types_1.typeforce.maybe(types_1.typeforce.Object),
+            output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+            pubkey: types_1.typeforce.maybe(types_1.isPoint),
+            signature: types_1.typeforce.maybe(
+                bscript.isCanonicalScriptSignature,
+            ),
+            input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+        },
+        a,
+    );
+    const _chunks = lazy.value(() => {
+        return bscript.decompile(a.input);
+    });
+    const network = a.network || networks_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_1.isPoint)(o.pubkey))
+                throw new TypeError('Output pubkey is invalid');
+            if (a.pubkey && !a.pubkey.equals(o.pubkey))
+                throw new TypeError('Pubkey mismatch');
+        }
+        if (a.signature) {
+            if (a.input && !a.input.equals(o.input))
+                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);
+}
+exports.p2pk = p2pk;

package/src/payments/p2pkh.d.ts

@@ -0,0 +1,10 @@
+import { Payment, PaymentOpts } from './index';
+/**
+ * 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.
+ */
+export declare function p2pkh(a: Payment, opts?: PaymentOpts): Payment;

package/src/payments/p2pkh.js

@@ -0,0 +1,143 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.p2pkh = void 0;
+const bcrypto = require('../crypto');
+const networks_1 = require('../networks');
+const bscript = require('../script');
+const types_1 = require('../types');
+const lazy = require('./lazy');
+const bs58check = require('bs58check');
+const OPS = bscript.OPS;
+// 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 || {});
+    (0, types_1.typeforce)(
+        {
+            network: types_1.typeforce.maybe(types_1.typeforce.Object),
+            address: types_1.typeforce.maybe(types_1.typeforce.String),
+            hash: types_1.typeforce.maybe(types_1.typeforce.BufferN(20)),
+            output: types_1.typeforce.maybe(types_1.typeforce.BufferN(25)),
+            pubkey: types_1.typeforce.maybe(types_1.isPoint),
+            signature: types_1.typeforce.maybe(
+                bscript.isCanonicalScriptSignature,
+            ),
+            input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+        },
+        a,
+    );
+    const _address = lazy.value(() => {
+        const payload = Buffer.from(bs58check.decode(a.address));
+        const version = payload.readUInt8(0);
+        const hash = payload.slice(1);
+        return { version, hash };
+    });
+    const _chunks = lazy.value(() => {
+        return bscript.decompile(a.input);
+    });
+    const network = a.network || networks_1.bitcoin;
+    const o = { name: 'p2pkh', network };
+    lazy.prop(o, 'address', () => {
+        if (!o.hash) return;
+        const payload = Buffer.allocUnsafe(21);
+        payload.writeUInt8(network.pubKeyHash, 0);
+        o.hash.copy(payload, 1);
+        return bs58check.encode(payload);
+    });
+    lazy.prop(o, 'hash', () => {
+        if (a.output) return a.output.slice(3, 23);
+        if (a.address) return _address().hash;
+        if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey || o.pubkey);
+    });
+    lazy.prop(o, 'output', () => {
+        if (!o.hash) return;
+        return bscript.compile([
+            OPS.OP_DUP,
+            OPS.OP_HASH160,
+            o.hash,
+            OPS.OP_EQUALVERIFY,
+            OPS.OP_CHECKSIG,
+        ]);
+    });
+    lazy.prop(o, 'pubkey', () => {
+        if (!a.input) return;
+        return _chunks()[1];
+    });
+    lazy.prop(o, 'signature', () => {
+        if (!a.input) return;
+        return _chunks()[0];
+    });
+    lazy.prop(o, 'input', () => {
+        if (!a.pubkey) return;
+        if (!a.signature) return;
+        return bscript.compile([a.signature, a.pubkey]);
+    });
+    lazy.prop(o, 'witness', () => {
+        if (!o.input) return;
+        return [];
+    });
+    // extended validation
+    if (opts.validate) {
+        let hash = Buffer.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 && !hash.equals(a.hash))
+                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 && !hash.equals(hash2))
+                throw new TypeError('Hash mismatch');
+            else hash = hash2;
+        }
+        if (a.pubkey) {
+            const pkh = bcrypto.hash160(a.pubkey);
+            if (hash.length > 0 && !hash.equals(pkh))
+                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 (!bscript.isCanonicalScriptSignature(chunks[0]))
+                throw new TypeError('Input has invalid signature');
+            if (!(0, types_1.isPoint)(chunks[1]))
+                throw new TypeError('Input has invalid pubkey');
+            if (a.signature && !a.signature.equals(chunks[0]))
+                throw new TypeError('Signature mismatch');
+            if (a.pubkey && !a.pubkey.equals(chunks[1]))
+                throw new TypeError('Pubkey mismatch');
+            const pkh = bcrypto.hash160(chunks[1]);
+            if (hash.length > 0 && !hash.equals(pkh))
+                throw new TypeError('Hash mismatch');
+        }
+    }
+    return Object.assign(o, a);
+}
+exports.p2pkh = p2pkh;

package/src/payments/p2sh.d.ts

@@ -0,0 +1,10 @@
+import { Payment, PaymentOpts } from './index';
+/**
+ * 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.
+ */
+export declare function p2sh(a: Payment, opts?: PaymentOpts): Payment;