@btc-vision/bitcoin 6.3.6 → 6.4.0

package/test/payments.spec.ts

@@ -1,125 +1,114 @@
-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);
-                            },
-                        );
-                    });
-                }
-            });
-        });
-    },
-);
+import assert from 'assert';
+import * as ecc from 'tiny-secp256k1';
+import { describe, it } from 'mocha';
+import { initEccLib, PaymentCreator } from '../src/index.js';
+import * as u from './payments.utils.js';
+import fs from 'node:fs';
+import { p2pk, p2wsh } from '../src/payments/index.js';
+
+const require = async (name: string) => {
+    const mod = await import(name);
+
+    return mod.default || mod;
+};
+
+['embed', 'p2ms', 'p2pk', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wsh', 'p2tr'].forEach((p) => {
+    describe(p, async () => {
+        beforeEach(() => {
+            initEccLib(p === 'p2tr' ? ecc : undefined);
+        });
+        let fn: PaymentCreator;
+        const payment = await require('../src/payments/' + p);
+        if (p === 'embed') {
+            fn = payment.p2data;
+        } else {
+            fn = payment[p];
+        }
+
+        const fixtures = JSON.parse(fs.readFileSync('test/fixtures/' + p + '.json', 'utf8'));
+        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') {
+            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.ts

@@ -1,208 +1,165 @@
-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;
-}
+import * as t from 'assert';
+import * as BNETWORKS from '../src/networks.js';
+import * as bscript from '../src/script.js';
+
+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;
+}