@btc-vision/bitcoin 6.3.1 → 6.3.2

package/test/payments.spec.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const ecc = require("tiny-secp256k1");
+const mocha_1 = require("mocha");
+const u = require("./payments.utils");
+const src_1 = require("../src");
+['embed', 'p2ms', 'p2pk', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wsh', 'p2tr'].forEach(p => {
+    (0, mocha_1.describe)(p, () => {
+        beforeEach(() => {
+            (0, src_1.initEccLib)(p === 'p2tr' ? ecc : undefined);
+        });
+        let fn;
+        const payment = require('../src/payments/' + p);
+        if (p === 'embed') {
+            fn = payment.p2data;
+        }
+        else {
+            fn = payment[p];
+        }
+        const fixtures = require('./fixtures/' + p);
+        fixtures.valid.forEach((f) => {
+            (0, mocha_1.it)(f.description + ' as expected', () => {
+                const args = u.preform(f.arguments);
+                const actual = fn(args, f.options);
+                u.equate(actual, f.expected, f.arguments);
+            });
+            (0, mocha_1.it)(f.description + ' as expected (no validation)', () => {
+                const args = u.preform(f.arguments);
+                const actual = fn(args, Object.assign({}, f.options, {
+                    validate: false,
+                }));
+                u.equate(actual, f.expected, f.arguments);
+            });
+        });
+        fixtures.invalid.forEach((f) => {
+            (0, mocha_1.it)('throws ' +
+                f.exception +
+                (f.description ? 'for ' + f.description : ''), () => {
+                const args = u.preform(f.arguments);
+                assert.throws(() => {
+                    fn(args, f.options);
+                }, new RegExp(f.exception));
+            });
+        });
+        if (p === 'p2sh') {
+            const p2wsh = require('../src/payments/p2wsh').p2wsh;
+            const p2pk = require('../src/payments/p2pk').p2pk;
+            (0, mocha_1.it)('properly assembles nested p2wsh with names', () => {
+                const actual = fn({
+                    redeem: p2wsh({
+                        redeem: p2pk({
+                            pubkey: Buffer.from('03e15819590382a9dd878f01e2f0cbce541564eb415e43b440472d883ecd283058', 'hex'),
+                        }),
+                    }),
+                });
+                assert.strictEqual(actual.address, '3MGbrbye4ttNUXM8WAvBFRKry4fkS9fjuw');
+                assert.strictEqual(actual.name, 'p2sh-p2wsh-p2pk');
+                assert.strictEqual(actual.redeem.name, 'p2wsh-p2pk');
+                assert.strictEqual(actual.redeem.redeem.name, 'p2pk');
+            });
+        }
+        // cross-verify dynamically too
+        if (!fixtures.dynamic)
+            return;
+        const { depends, details } = fixtures.dynamic;
+        details.forEach((f) => {
+            const detail = u.preform(f);
+            const disabled = {};
+            if (f.disabled)
+                f.disabled.forEach((k) => {
+                    disabled[k] = true;
+                });
+            for (const key in depends) {
+                if (key in disabled)
+                    continue;
+                const dependencies = depends[key];
+                dependencies.forEach((dependency) => {
+                    if (!Array.isArray(dependency))
+                        dependency = [dependency];
+                    const args = {};
+                    dependency.forEach((d) => {
+                        u.from(d, detail, args);
+                    });
+                    const expected = u.from(key, detail);
+                    (0, mocha_1.it)(f.description +
+                        ', ' +
+                        key +
+                        ' derives from ' +
+                        JSON.stringify(dependency), () => {
+                        u.equate(fn(args), expected);
+                    });
+                });
+            }
+        });
+    });
+});

package/test/payments.spec.ts

@@ -0,0 +1,125 @@
+import * as assert from 'assert';
+import * as ecc from 'tiny-secp256k1';
+import { describe, it } from 'mocha';
+import { PaymentCreator } from '../src/payments';
+import * as u from './payments.utils';
+import { initEccLib } from '../src';
+
+['embed', 'p2ms', 'p2pk', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wsh', 'p2tr'].forEach(
+    p => {
+        describe(p, () => {
+            beforeEach(() => {
+                initEccLib(p === 'p2tr' ? ecc : undefined);
+            });
+            let fn: PaymentCreator;
+            const payment = require('../src/payments/' + p);
+            if (p === 'embed') {
+                fn = payment.p2data;
+            } else {
+                fn = payment[p];
+            }
+
+            const fixtures = require('./fixtures/' + p);
+
+            fixtures.valid.forEach((f: any) => {
+                it(f.description + ' as expected', () => {
+                    const args = u.preform(f.arguments);
+                    const actual = fn(args, f.options);
+
+                    u.equate(actual, f.expected, f.arguments);
+                });
+
+                it(f.description + ' as expected (no validation)', () => {
+                    const args = u.preform(f.arguments);
+                    const actual = fn(
+                        args,
+                        Object.assign({}, f.options, {
+                            validate: false,
+                        }),
+                    );
+
+                    u.equate(actual, f.expected, f.arguments);
+                });
+            });
+
+            fixtures.invalid.forEach((f: any) => {
+                it(
+                    'throws ' +
+                        f.exception +
+                        (f.description ? 'for ' + f.description : ''),
+                    () => {
+                        const args = u.preform(f.arguments);
+
+                        assert.throws(() => {
+                            fn(args, f.options);
+                        }, new RegExp(f.exception));
+                    },
+                );
+            });
+
+            if (p === 'p2sh') {
+                const p2wsh = require('../src/payments/p2wsh').p2wsh;
+                const p2pk = require('../src/payments/p2pk').p2pk;
+                it('properly assembles nested p2wsh with names', () => {
+                    const actual = fn({
+                        redeem: p2wsh({
+                            redeem: p2pk({
+                                pubkey: Buffer.from(
+                                    '03e15819590382a9dd878f01e2f0cbce541564eb415e43b440472d883ecd283058',
+                                    'hex',
+                                ),
+                            }),
+                        }),
+                    });
+                    assert.strictEqual(
+                        actual.address,
+                        '3MGbrbye4ttNUXM8WAvBFRKry4fkS9fjuw',
+                    );
+                    assert.strictEqual(actual.name, 'p2sh-p2wsh-p2pk');
+                    assert.strictEqual(actual.redeem!.name, 'p2wsh-p2pk');
+                    assert.strictEqual(actual.redeem!.redeem!.name, 'p2pk');
+                });
+            }
+
+            // cross-verify dynamically too
+            if (!fixtures.dynamic) return;
+            const { depends, details } = fixtures.dynamic;
+
+            details.forEach((f: any) => {
+                const detail = u.preform(f);
+                const disabled: any = {};
+                if (f.disabled)
+                    f.disabled.forEach((k: string) => {
+                        disabled[k] = true;
+                    });
+
+                for (const key in depends) {
+                    if (key in disabled) continue;
+                    const dependencies = depends[key];
+
+                    dependencies.forEach((dependency: any) => {
+                        if (!Array.isArray(dependency))
+                            dependency = [dependency];
+
+                        const args = {};
+                        dependency.forEach((d: any) => {
+                            u.from(d, detail, args);
+                        });
+                        const expected = u.from(key, detail);
+
+                        it(
+                            f.description +
+                                ', ' +
+                                key +
+                                ' derives from ' +
+                                JSON.stringify(dependency),
+                            () => {
+                                u.equate(fn(args), expected);
+                            },
+                        );
+                    });
+                }
+            });
+        });
+    },
+);

package/test/payments.utils.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertScriptTree = exports.from = exports.preform = exports.equate = void 0;
+const t = require("assert");
+const BNETWORKS = require("../src/networks");
+const bscript = require("../src/script");
+function tryHex(x) {
+    if (Buffer.isBuffer(x))
+        return x.toString('hex');
+    if (Array.isArray(x))
+        return x.map(tryHex);
+    return x;
+}
+function fromHex(x) {
+    if (typeof x === 'string')
+        return Buffer.from(x, 'hex');
+    if (Array.isArray(x))
+        return x.map(fromHex);
+    return x;
+}
+function tryASM(x) {
+    if (Buffer.isBuffer(x))
+        return bscript.toASM(x);
+    return x;
+}
+function asmToBuffer(x) {
+    if (x === '')
+        return Buffer.alloc(0);
+    return bscript.fromASM(x);
+}
+function carryOver(a, b) {
+    for (const k in b) {
+        if (!k)
+            continue;
+        if (k in a && k === 'redeem') {
+            carryOver(a[k], b[k]);
+            continue;
+        }
+        // don't, the value was specified
+        if (k in a)
+            continue;
+        // otherwise, expect match
+        a[k] = b[k];
+    }
+}
+function equateBase(a, b, context) {
+    if ('output' in b)
+        t.strictEqual(tryASM(a.output), tryASM(b.output), `Inequal ${context}output`);
+    if ('input' in b)
+        t.strictEqual(tryASM(a.input), tryASM(b.input), `Inequal ${context}input`);
+    if ('witness' in b)
+        t.deepStrictEqual(tryHex(a.witness), tryHex(b.witness), `Inequal ${context}witness`);
+    if ('redeemVersion' in b)
+        t.strictEqual(a.redeemVersion, b.redeemVersion, `Inequal ${context}redeemVersion`);
+}
+function equate(a, b, args) {
+    b = Object.assign({}, b);
+    carryOver(b, args);
+    // by null, we mean 'undefined', but JSON
+    if (b.input === null)
+        b.input = undefined;
+    if (b.output === null)
+        b.output = undefined;
+    if (b.witness === null)
+        b.witness = undefined;
+    if (b.redeemVersion === null)
+        b.redeemVersion = undefined;
+    if (b.redeem) {
+        if (b.redeem.input === null)
+            b.redeem.input = undefined;
+        if (b.redeem.output === null)
+            b.redeem.output = undefined;
+        if (b.redeem.witness === null)
+            b.redeem.witness = undefined;
+        if (b.redeem.redeemVersion === null)
+            b.redeem.redeemVersion = undefined;
+    }
+    equateBase(a, b, '');
+    if (b.redeem)
+        equateBase(a.redeem, b.redeem, 'redeem.');
+    if (b.network)
+        t.deepStrictEqual(a.network, BNETWORKS[b.network], 'Inequal *.network');
+    // contextual
+    if (b.signature === null)
+        b.signature = undefined;
+    if (b.signatures === null)
+        b.signatures = undefined;
+    if ('address' in b)
+        t.strictEqual(a.address, b.address, 'Inequal *.address');
+    if ('name' in b)
+        t.strictEqual(a.name, b.name, 'Inequal *.name');
+    if ('hash' in b)
+        t.strictEqual(tryHex(a.hash), tryHex(b.hash), 'Inequal *.hash');
+    if ('pubkey' in b)
+        t.strictEqual(tryHex(a.pubkey), tryHex(b.pubkey), 'Inequal *.pubkey');
+    if ('internalPubkey' in b)
+        t.strictEqual(tryHex(a.internalPubkey), tryHex(b.internalPubkey), 'Inequal *.internalPubkey');
+    if ('signature' in b)
+        t.strictEqual(tryHex(a.signature), tryHex(b.signature), 'Inequal signature');
+    if ('m' in b)
+        t.strictEqual(a.m, b.m, 'Inequal *.m');
+    if ('n' in b)
+        t.strictEqual(a.n, b.n, 'Inequal *.n');
+    if ('pubkeys' in b)
+        t.deepStrictEqual(tryHex(a.pubkeys), tryHex(b.pubkeys), 'Inequal *.pubkeys');
+    if ('signatures' in b)
+        t.deepStrictEqual(tryHex(a.signatures), tryHex(b.signatures), 'Inequal *.signatures');
+    if ('data' in b)
+        t.deepStrictEqual(tryHex(a.data), tryHex(b.data), 'Inequal *.data');
+}
+exports.equate = equate;
+function preform(x) {
+    x = Object.assign({}, x);
+    if (x.network)
+        x.network = BNETWORKS[x.network];
+    if (typeof x.inputHex === 'string') {
+        x.input = Buffer.from(x.inputHex, 'hex');
+        delete x.inputHex;
+    }
+    if (typeof x.outputHex === 'string') {
+        x.output = Buffer.from(x.outputHex, 'hex');
+        delete x.outputHex;
+    }
+    if (typeof x.output === 'string')
+        x.output = asmToBuffer(x.output);
+    if (typeof x.input === 'string')
+        x.input = asmToBuffer(x.input);
+    if (Array.isArray(x.witness))
+        x.witness = x.witness.map(fromHex);
+    if (x.data)
+        x.data = x.data.map(fromHex);
+    if (x.hash)
+        x.hash = Buffer.from(x.hash, 'hex');
+    if (x.pubkey)
+        x.pubkey = Buffer.from(x.pubkey, 'hex');
+    if (x.internalPubkey)
+        x.internalPubkey = Buffer.from(x.internalPubkey, 'hex');
+    if (x.signature)
+        x.signature = Buffer.from(x.signature, 'hex');
+    if (x.pubkeys)
+        x.pubkeys = x.pubkeys.map(fromHex);
+    if (x.signatures)
+        x.signatures = x.signatures.map((y) => {
+            return Number.isFinite(y) ? y : Buffer.from(y, 'hex');
+        });
+    if (x.redeem) {
+        x.redeem = Object.assign({}, x.redeem);
+        if (typeof x.redeem.input === 'string')
+            x.redeem.input = asmToBuffer(x.redeem.input);
+        if (typeof x.redeem.output === 'string')
+            x.redeem.output = asmToBuffer(x.redeem.output);
+        if (Array.isArray(x.redeem.witness))
+            x.redeem.witness = x.redeem.witness.map(fromHex);
+        if (x.redeem.network)
+            x.redeem.network = BNETWORKS[x.redeem.network];
+    }
+    if (x.scriptTree)
+        x.scriptTree = convertScriptTree(x.scriptTree);
+    return x;
+}
+exports.preform = preform;
+function from(path, object, result) {
+    const paths = path.split('.');
+    result = result || {};
+    let r = result;
+    paths.forEach((k, i) => {
+        if (i < paths.length - 1) {
+            r[k] = r[k] || {};
+            // recurse
+            r = r[k];
+            object = object[k];
+        }
+        else {
+            r[k] = object[k];
+        }
+    });
+    return result;
+}
+exports.from = from;
+function convertScriptTree(scriptTree, leafVersion) {
+    if (Array.isArray(scriptTree))
+        return scriptTree.map(tr => convertScriptTree(tr, leafVersion));
+    const script = Object.assign({}, scriptTree);
+    if (typeof script.output === 'string') {
+        script.output = asmToBuffer(scriptTree.output);
+        script.version = script.version || leafVersion;
+    }
+    return script;
+}
+exports.convertScriptTree = convertScriptTree;

package/test/payments.utils.ts

@@ -0,0 +1,208 @@
+import * as t from 'assert';
+import * as BNETWORKS from '../src/networks';
+import * as bscript from '../src/script';
+
+function tryHex(x: Buffer | Buffer[]): string | string[] {
+    if (Buffer.isBuffer(x)) return x.toString('hex');
+    if (Array.isArray(x)) return x.map(tryHex) as string[];
+    return x;
+}
+
+function fromHex(x: string | string[]): Buffer | Buffer[] {
+    if (typeof x === 'string') return Buffer.from(x, 'hex');
+    if (Array.isArray(x)) return x.map(fromHex) as Buffer[];
+    return x;
+}
+
+function tryASM(x: Buffer): string {
+    if (Buffer.isBuffer(x)) return bscript.toASM(x);
+    return x;
+}
+
+function asmToBuffer(x: string): Buffer {
+    if (x === '') return Buffer.alloc(0);
+    return bscript.fromASM(x);
+}
+
+function carryOver(a: any, b: any): void {
+    for (const k in b) {
+        if (!k) continue;
+        if (k in a && k === 'redeem') {
+            carryOver(a[k], b[k]);
+            continue;
+        }
+
+        // don't, the value was specified
+        if (k in a) continue;
+
+        // otherwise, expect match
+        a[k] = b[k];
+    }
+}
+
+function equateBase(a: any, b: any, context: string): void {
+    if ('output' in b)
+        t.strictEqual(
+            tryASM(a.output),
+            tryASM(b.output),
+            `Inequal ${context}output`,
+        );
+    if ('input' in b)
+        t.strictEqual(
+            tryASM(a.input),
+            tryASM(b.input),
+            `Inequal ${context}input`,
+        );
+    if ('witness' in b)
+        t.deepStrictEqual(
+            tryHex(a.witness),
+            tryHex(b.witness),
+            `Inequal ${context}witness`,
+        );
+    if ('redeemVersion' in b)
+        t.strictEqual(
+            a.redeemVersion,
+            b.redeemVersion,
+            `Inequal ${context}redeemVersion`,
+        );
+}
+
+export function equate(a: any, b: any, args?: any): void {
+    b = Object.assign({}, b);
+    carryOver(b, args);
+
+    // by null, we mean 'undefined', but JSON
+    if (b.input === null) b.input = undefined;
+    if (b.output === null) b.output = undefined;
+    if (b.witness === null) b.witness = undefined;
+    if (b.redeemVersion === null) b.redeemVersion = undefined;
+    if (b.redeem) {
+        if (b.redeem.input === null) b.redeem.input = undefined;
+        if (b.redeem.output === null) b.redeem.output = undefined;
+        if (b.redeem.witness === null) b.redeem.witness = undefined;
+        if (b.redeem.redeemVersion === null) b.redeem.redeemVersion = undefined;
+    }
+
+    equateBase(a, b, '');
+    if (b.redeem) equateBase(a.redeem, b.redeem, 'redeem.');
+    if (b.network)
+        t.deepStrictEqual(
+            a.network,
+            (BNETWORKS as any)[b.network],
+            'Inequal *.network',
+        );
+
+    // contextual
+    if (b.signature === null) b.signature = undefined;
+    if (b.signatures === null) b.signatures = undefined;
+    if ('address' in b)
+        t.strictEqual(a.address, b.address, 'Inequal *.address');
+    if ('name' in b) t.strictEqual(a.name, b.name, 'Inequal *.name');
+    if ('hash' in b)
+        t.strictEqual(tryHex(a.hash), tryHex(b.hash), 'Inequal *.hash');
+    if ('pubkey' in b)
+        t.strictEqual(tryHex(a.pubkey), tryHex(b.pubkey), 'Inequal *.pubkey');
+    if ('internalPubkey' in b)
+        t.strictEqual(
+            tryHex(a.internalPubkey),
+            tryHex(b.internalPubkey),
+            'Inequal *.internalPubkey',
+        );
+    if ('signature' in b)
+        t.strictEqual(
+            tryHex(a.signature),
+            tryHex(b.signature),
+            'Inequal signature',
+        );
+    if ('m' in b) t.strictEqual(a.m, b.m, 'Inequal *.m');
+    if ('n' in b) t.strictEqual(a.n, b.n, 'Inequal *.n');
+    if ('pubkeys' in b)
+        t.deepStrictEqual(
+            tryHex(a.pubkeys),
+            tryHex(b.pubkeys),
+            'Inequal *.pubkeys',
+        );
+    if ('signatures' in b)
+        t.deepStrictEqual(
+            tryHex(a.signatures),
+            tryHex(b.signatures),
+            'Inequal *.signatures',
+        );
+    if ('data' in b)
+        t.deepStrictEqual(tryHex(a.data), tryHex(b.data), 'Inequal *.data');
+}
+
+export function preform(x: any): any {
+    x = Object.assign({}, x);
+
+    if (x.network) x.network = (BNETWORKS as any)[x.network];
+    if (typeof x.inputHex === 'string') {
+        x.input = Buffer.from(x.inputHex, 'hex');
+        delete x.inputHex;
+    }
+    if (typeof x.outputHex === 'string') {
+        x.output = Buffer.from(x.outputHex, 'hex');
+        delete x.outputHex;
+    }
+    if (typeof x.output === 'string') x.output = asmToBuffer(x.output);
+    if (typeof x.input === 'string') x.input = asmToBuffer(x.input);
+    if (Array.isArray(x.witness)) x.witness = x.witness.map(fromHex);
+
+    if (x.data) x.data = x.data.map(fromHex);
+    if (x.hash) x.hash = Buffer.from(x.hash, 'hex');
+    if (x.pubkey) x.pubkey = Buffer.from(x.pubkey, 'hex');
+    if (x.internalPubkey)
+        x.internalPubkey = Buffer.from(x.internalPubkey, 'hex');
+    if (x.signature) x.signature = Buffer.from(x.signature, 'hex');
+    if (x.pubkeys) x.pubkeys = x.pubkeys.map(fromHex);
+    if (x.signatures)
+        x.signatures = x.signatures.map((y: any) => {
+            return Number.isFinite(y) ? y : Buffer.from(y, 'hex');
+        });
+    if (x.redeem) {
+        x.redeem = Object.assign({}, x.redeem);
+        if (typeof x.redeem.input === 'string')
+            x.redeem.input = asmToBuffer(x.redeem.input);
+        if (typeof x.redeem.output === 'string')
+            x.redeem.output = asmToBuffer(x.redeem.output);
+        if (Array.isArray(x.redeem.witness))
+            x.redeem.witness = x.redeem.witness.map(fromHex);
+        if (x.redeem.network)
+            x.redeem.network = (BNETWORKS as any)[x.redeem.network];
+    }
+
+    if (x.scriptTree) x.scriptTree = convertScriptTree(x.scriptTree);
+    return x;
+}
+
+export function from(path: string, object: any, result?: any): any {
+    const paths = path.split('.');
+    result = result || {};
+
+    let r = result;
+    paths.forEach((k, i) => {
+        if (i < paths.length - 1) {
+            r[k] = r[k] || {};
+
+            // recurse
+            r = r[k];
+            object = object[k];
+        } else {
+            r[k] = object[k];
+        }
+    });
+
+    return result;
+}
+
+export function convertScriptTree(scriptTree: any, leafVersion?: number): any {
+    if (Array.isArray(scriptTree))
+        return scriptTree.map(tr => convertScriptTree(tr, leafVersion));
+
+    const script = Object.assign({}, scriptTree);
+    if (typeof script.output === 'string') {
+        script.output = asmToBuffer(scriptTree.output);
+        script.version = script.version || leafVersion;
+    }
+    return script;
+}