@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/types.ts

@@ -0,0 +1,122 @@
+import { Buffer as NBuffer } from 'buffer';
+
+// @ts-ignore
+import * as _typeforce from 'typeforce';
+
+export const typeforce = _typeforce.default;
+
+const ZERO32 = NBuffer.alloc(32, 0);
+const EC_P = NBuffer.from(
+    'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
+    'hex',
+);
+
+/**
+ * Checks if two arrays of Buffers are equal.
+ * @param a - The first array of Buffers.
+ * @param b - The second array of Buffers.
+ * @returns True if the arrays are equal, false otherwise.
+ */
+export function stacksEqual(a: Buffer[], b: Buffer[]): boolean {
+    if (a.length !== b.length) return false;
+
+    return a.every((x, i) => {
+        return x.equals(b[i]);
+    });
+}
+
+/**
+ * Checks if the given value is a valid elliptic curve point.
+ * @param p - The value to check.
+ * @returns True if the value is a valid elliptic curve point, false otherwise.
+ */
+export function isPoint(p: Buffer | number | undefined | null): boolean {
+    if (!NBuffer.isBuffer(p)) return false;
+    if (p.length < 33) return false;
+
+    const t = p[0]; // First byte = point format indicator
+    const x = p.slice(1, 33); // Next 32 bytes = X coordinate
+
+    // Validate X coordinate
+    if (x.compare(ZERO32) === 0) return false; // X cannot be zero
+    if (x.compare(EC_P) >= 0) return false; // X must be < P
+
+    // Check for compressed format (0x02 or 0x03), must be exactly 33 bytes total
+    if ((t === 0x02 || t === 0x03) && p.length === 33) {
+        return true;
+    }
+
+    // For uncompressed (0x04) or hybrid (0x06 or 0x07) formats, must be 65 bytes total
+    if (p.length !== 65) return false;
+
+    const y = p.slice(33); // Last 32 bytes = Y coordinate
+
+    // Validate Y coordinate
+    if (y.compare(ZERO32) === 0) return false; // Y cannot be zero
+    if (y.compare(EC_P) >= 0) return false; // Y must be < P
+
+    // 0x04 = uncompressed, 0x06/0x07 = hybrid (also 65 bytes, but with Y's parity bit set)
+    return t === 0x04 || t === 0x06 || t === 0x07;
+}
+
+const SATOSHI_MAX: number = 21 * 1e14;
+
+export function Satoshi(value: number): boolean {
+    return typeforce.UInt53(value) && value <= SATOSHI_MAX;
+}
+
+export interface XOnlyPointAddTweakResult {
+    parity: 1 | 0;
+    xOnlyPubkey: Uint8Array;
+}
+
+export interface Tapleaf {
+    output: Buffer;
+    version?: number;
+}
+
+export const TAPLEAF_VERSION_MASK = 0xfe;
+
+export function isTapleaf(o: any): o is Tapleaf {
+    if (!o || !('output' in o)) return false;
+    if (!NBuffer.isBuffer(o.output)) return false;
+    if (o.version !== undefined) return (o.version & TAPLEAF_VERSION_MASK) === o.version;
+    return true;
+}
+
+/**
+ * Binary tree repsenting script path spends for a Taproot input.
+ * Each node is either a single Tapleaf, or a pair of Tapleaf | Taptree.
+ * The tree has no balancing requirements.
+ */
+export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
+
+export function isTaptree(scriptTree: any): scriptTree is Taptree {
+    if (!Array(scriptTree)) return isTapleaf(scriptTree);
+    if (scriptTree.length !== 2) return false;
+    return scriptTree.every((t: any) => isTaptree(t));
+}
+
+export interface TinySecp256k1Interface {
+    isXOnlyPoint(p: Uint8Array): boolean;
+
+    xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
+}
+
+export const Buffer256bit = typeforce.BufferN(32);
+export const Hash160bit = typeforce.BufferN(20);
+export const Hash256bit = typeforce.BufferN(32);
+export const Number = typeforce.Number;
+export const Array = typeforce.Array;
+export const Boolean = typeforce.Boolean;
+export const String = typeforce.String;
+export const Buffer = typeforce.Buffer;
+export const Hex = typeforce.Hex;
+export const maybe = typeforce.maybe;
+export const tuple = typeforce.tuple;
+export const UInt8 = typeforce.UInt8;
+export const UInt32 = typeforce.UInt32;
+export const Function = typeforce.Function;
+export const BufferN = typeforce.BufferN;
+export const Null = typeforce.Null;
+export const oneOf = typeforce.oneOf;

package/test/address.spec.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const mocha_1 = require("mocha");
+const ecc = require("tiny-secp256k1");
+const baddress = require("../src/address");
+const bscript = require("../src/script");
+const fixtures = require("./fixtures/address.json");
+const src_1 = require("../src");
+const NETWORKS = Object.assign({
+    litecoin: {
+        messagePrefix: '\x19Litecoin Signed Message:\n',
+        bip32: {
+            public: 0x019da462,
+            private: 0x019d9cfe,
+        },
+        pubKeyHash: 0x30,
+        scriptHash: 0x32,
+        wif: 0xb0,
+    },
+}, require('../src/networks'));
+(0, mocha_1.describe)('address', () => {
+    (0, mocha_1.describe)('fromBase58Check', () => {
+        fixtures.standard.forEach(f => {
+            if (!f.base58check)
+                return;
+            (0, mocha_1.it)('decodes ' + f.base58check, () => {
+                const decode = baddress.fromBase58Check(f.base58check);
+                assert.strictEqual(decode.version, f.version);
+                assert.strictEqual(decode.hash.toString('hex'), f.hash);
+            });
+        });
+        fixtures.invalid.fromBase58Check.forEach(f => {
+            (0, mocha_1.it)('throws on ' + f.exception, () => {
+                assert.throws(() => {
+                    baddress.fromBase58Check(f.address);
+                }, new RegExp(f.address + ' ' + f.exception));
+            });
+        });
+    });
+    (0, mocha_1.describe)('fromBech32', () => {
+        fixtures.standard.forEach(f => {
+            if (!f.bech32)
+                return;
+            (0, mocha_1.it)('decodes ' + f.bech32, () => {
+                const actual = baddress.fromBech32(f.bech32);
+                assert.strictEqual(actual.version, f.version);
+                assert.strictEqual(actual.prefix, NETWORKS[f.network].bech32);
+                assert.strictEqual(actual.data.toString('hex'), f.data);
+            });
+        });
+        fixtures.invalid.bech32.forEach(f => {
+            (0, mocha_1.it)('decode fails for ' + f.address + '(' + f.exception + ')', () => {
+                assert.throws(() => {
+                    baddress.fromBech32(f.address);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+    (0, mocha_1.describe)('fromOutputScript', () => {
+        (0, src_1.initEccLib)(ecc);
+        fixtures.standard.forEach(f => {
+            (0, mocha_1.it)('encodes ' + f.script.slice(0, 30) + '... (' + f.network + ')', () => {
+                const script = bscript.fromASM(f.script);
+                const address = baddress.fromOutputScript(script, NETWORKS[f.network]);
+                assert.strictEqual(address, f.base58check || f.bech32.toLowerCase());
+            });
+        });
+        fixtures.invalid.fromOutputScript.forEach(f => {
+            (0, mocha_1.it)('throws when ' + f.script.slice(0, 30) + '... ' + f.exception, () => {
+                const script = bscript.fromASM(f.script);
+                assert.throws(() => {
+                    baddress.fromOutputScript(script, undefined);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+    (0, mocha_1.describe)('toBase58Check', () => {
+        fixtures.standard.forEach(f => {
+            if (!f.base58check)
+                return;
+            (0, mocha_1.it)('encodes ' + f.hash + ' (' + f.network + ')', () => {
+                const address = baddress.toBase58Check(Buffer.from(f.hash, 'hex'), f.version);
+                assert.strictEqual(address, f.base58check);
+            });
+        });
+    });
+    (0, mocha_1.describe)('toBech32', () => {
+        fixtures.bech32.forEach(f => {
+            if (!f.address)
+                return;
+            const data = Buffer.from(f.data, 'hex');
+            (0, mocha_1.it)('encode ' + f.address, () => {
+                assert.deepStrictEqual(baddress.toBech32(data, f.version, f.prefix), f.address.toLowerCase());
+            });
+        });
+        // TODO: These fixtures (according to TypeScript) have none of the data used below
+        fixtures.invalid.bech32.forEach((f) => {
+            if (!f.prefix || f.version === undefined || f.data === undefined)
+                return;
+            (0, mocha_1.it)('encode fails (' + f.exception, () => {
+                assert.throws(() => {
+                    baddress.toBech32(Buffer.from(f.data, 'hex'), f.version, f.prefix);
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+    (0, mocha_1.describe)('toOutputScript', () => {
+        fixtures.standard.forEach(f => {
+            (0, mocha_1.it)('decodes ' + f.script.slice(0, 30) + '... (' + f.network + ')', () => {
+                const script = baddress.toOutputScript((f.base58check || f.bech32), NETWORKS[f.network]);
+                assert.strictEqual(bscript.toASM(script), f.script);
+            });
+        });
+        fixtures.invalid.toOutputScript.forEach(f => {
+            (0, mocha_1.it)('throws when ' + (f.exception || f.paymentException), () => {
+                const exception = f.paymentException || `${f.address} ${f.exception}`;
+                assert.throws(() => {
+                    baddress.toOutputScript(f.address, f.network);
+                }, new RegExp(exception));
+            });
+        });
+    });
+});

package/test/address.spec.ts

@@ -0,0 +1,177 @@
+import * as assert from 'assert';
+import { describe, it } from 'mocha';
+import * as ecc from 'tiny-secp256k1';
+import * as baddress from '../src/address';
+import * as bscript from '../src/script';
+import * as fixtures from './fixtures/address.json';
+
+import { initEccLib } from '../src';
+
+const NETWORKS = Object.assign(
+    {
+        litecoin: {
+            messagePrefix: '\x19Litecoin Signed Message:\n',
+            bip32: {
+                public: 0x019da462,
+                private: 0x019d9cfe,
+            },
+            pubKeyHash: 0x30,
+            scriptHash: 0x32,
+            wif: 0xb0,
+        },
+    },
+    require('../src/networks'),
+);
+
+describe('address', () => {
+    describe('fromBase58Check', () => {
+        fixtures.standard.forEach(f => {
+            if (!f.base58check) return;
+
+            it('decodes ' + f.base58check, () => {
+                const decode = baddress.fromBase58Check(f.base58check);
+
+                assert.strictEqual(decode.version, f.version);
+                assert.strictEqual(decode.hash.toString('hex'), f.hash);
+            });
+        });
+
+        fixtures.invalid.fromBase58Check.forEach(f => {
+            it('throws on ' + f.exception, () => {
+                assert.throws(() => {
+                    baddress.fromBase58Check(f.address);
+                }, new RegExp(f.address + ' ' + f.exception));
+            });
+        });
+    });
+
+    describe('fromBech32', () => {
+        fixtures.standard.forEach(f => {
+            if (!f.bech32) return;
+
+            it('decodes ' + f.bech32, () => {
+                const actual = baddress.fromBech32(f.bech32);
+
+                assert.strictEqual(actual.version, f.version);
+                assert.strictEqual(actual.prefix, NETWORKS[f.network].bech32);
+                assert.strictEqual(actual.data.toString('hex'), f.data);
+            });
+        });
+
+        fixtures.invalid.bech32.forEach(f => {
+            it(
+                'decode fails for ' + f.address + '(' + f.exception + ')',
+                () => {
+                    assert.throws(() => {
+                        baddress.fromBech32(f.address);
+                    }, new RegExp(f.exception));
+                },
+            );
+        });
+    });
+
+    describe('fromOutputScript', () => {
+        initEccLib(ecc);
+        fixtures.standard.forEach(f => {
+            it(
+                'encodes ' + f.script.slice(0, 30) + '... (' + f.network + ')',
+                () => {
+                    const script = bscript.fromASM(f.script);
+                    const address = baddress.fromOutputScript(
+                        script,
+                        NETWORKS[f.network],
+                    );
+
+                    assert.strictEqual(
+                        address,
+                        f.base58check || f.bech32!.toLowerCase(),
+                    );
+                },
+            );
+        });
+
+        fixtures.invalid.fromOutputScript.forEach(f => {
+            it(
+                'throws when ' + f.script.slice(0, 30) + '... ' + f.exception,
+                () => {
+                    const script = bscript.fromASM(f.script);
+
+                    assert.throws(() => {
+                        baddress.fromOutputScript(script, undefined);
+                    }, new RegExp(f.exception));
+                },
+            );
+        });
+    });
+
+    describe('toBase58Check', () => {
+        fixtures.standard.forEach(f => {
+            if (!f.base58check) return;
+
+            it('encodes ' + f.hash + ' (' + f.network + ')', () => {
+                const address = baddress.toBase58Check(
+                    Buffer.from(f.hash, 'hex'),
+                    f.version,
+                );
+
+                assert.strictEqual(address, f.base58check);
+            });
+        });
+    });
+
+    describe('toBech32', () => {
+        fixtures.bech32.forEach(f => {
+            if (!f.address) return;
+            const data = Buffer.from(f.data, 'hex');
+
+            it('encode ' + f.address, () => {
+                assert.deepStrictEqual(
+                    baddress.toBech32(data, f.version, f.prefix),
+                    f.address.toLowerCase(),
+                );
+            });
+        });
+
+        // TODO: These fixtures (according to TypeScript) have none of the data used below
+        fixtures.invalid.bech32.forEach((f: any) => {
+            if (!f.prefix || f.version === undefined || f.data === undefined)
+                return;
+
+            it('encode fails (' + f.exception, () => {
+                assert.throws(() => {
+                    baddress.toBech32(
+                        Buffer.from(f.data, 'hex'),
+                        f.version,
+                        f.prefix,
+                    );
+                }, new RegExp(f.exception));
+            });
+        });
+    });
+
+    describe('toOutputScript', () => {
+        fixtures.standard.forEach(f => {
+            it(
+                'decodes ' + f.script.slice(0, 30) + '... (' + f.network + ')',
+                () => {
+                    const script = baddress.toOutputScript(
+                        (f.base58check || f.bech32)!,
+                        NETWORKS[f.network],
+                    );
+
+                    assert.strictEqual(bscript.toASM(script), f.script);
+                },
+            );
+        });
+
+        fixtures.invalid.toOutputScript.forEach(f => {
+            it('throws when ' + (f.exception || f.paymentException), () => {
+                const exception =
+                    f.paymentException || `${f.address} ${f.exception}`;
+                assert.throws(() => {
+                    baddress.toOutputScript(f.address, f.network as any);
+                }, new RegExp(exception));
+            });
+        });
+    });
+});

package/test/bitcoin.core.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const base58 = require("bs58");
+const mocha_1 = require("mocha");
+const bitcoin = require("..");
+const base58EncodeDecode = require("./fixtures/core/base58_encode_decode.json");
+const base58KeysInvalid = require("./fixtures/core/base58_keys_invalid.json");
+const base58KeysValid = require("./fixtures/core/base58_keys_valid.json");
+const blocksValid = require("./fixtures/core/blocks.json");
+const sigCanonical = require("./fixtures/core/sig_canonical.json");
+const sigNoncanonical = require("./fixtures/core/sig_noncanonical.json");
+const sigHash = require("./fixtures/core/sighash.json");
+const txValid = require("./fixtures/core/tx_valid.json");
+(0, mocha_1.describe)('Bitcoin-core', () => {
+    // base58EncodeDecode
+    (0, mocha_1.describe)('base58', () => {
+        base58EncodeDecode.forEach(f => {
+            const fhex = f[0];
+            const fb58 = f[1];
+            (0, mocha_1.it)('can decode ' + fb58, () => {
+                const buffer = base58.decode(fb58);
+                const actual = buffer.toString('hex');
+                assert.strictEqual(actual, fhex);
+            });
+            (0, mocha_1.it)('can encode ' + fhex, () => {
+                const buffer = Buffer.from(fhex, 'hex');
+                const actual = base58.encode(buffer);
+                assert.strictEqual(actual, fb58);
+            });
+        });
+    });
+    // base58KeysValid
+    (0, mocha_1.describe)('address.toBase58Check', () => {
+        const typeMap = {
+            pubkey: 'pubKeyHash',
+            script: 'scriptHash',
+        };
+        base58KeysValid.forEach(f => {
+            const expected = f[0];
+            const hash = Buffer.from(f[1], 'hex');
+            const params = f[2];
+            if (params.isPrivkey)
+                return;
+            const network = params.isTestnet
+                ? bitcoin.networks.testnet
+                : bitcoin.networks.bitcoin;
+            const version = network[typeMap[params.addrType]];
+            (0, mocha_1.it)('can export ' + expected, () => {
+                assert.strictEqual(bitcoin.address.toBase58Check(hash, version), expected);
+            });
+        });
+    });
+    // base58KeysInvalid
+    (0, mocha_1.describe)('address.fromBase58Check', () => {
+        const allowedNetworks = [
+            bitcoin.networks.bitcoin.pubKeyHash,
+            bitcoin.networks.bitcoin.scriptHash,
+            bitcoin.networks.testnet.pubKeyHash,
+            bitcoin.networks.testnet.scriptHash,
+        ];
+        base58KeysInvalid.forEach(f => {
+            const strng = f[0];
+            (0, mocha_1.it)('throws on ' + strng, () => {
+                assert.throws(() => {
+                    const address = bitcoin.address.fromBase58Check(strng);
+                    assert.notStrictEqual(allowedNetworks.indexOf(address.version), -1, 'Invalid network');
+                }, /(Invalid (checksum|network))|(too (short|long))/);
+            });
+        });
+    });
+    (0, mocha_1.describe)('Block.fromHex', () => {
+        blocksValid.forEach(f => {
+            (0, mocha_1.it)('can parse ' + f.id, () => {
+                const block = bitcoin.Block.fromHex(f.hex);
+                assert.strictEqual(block.getId(), f.id);
+                assert.strictEqual(block.transactions.length, f.transactions);
+            });
+        });
+    });
+    // txValid
+    (0, mocha_1.describe)('Transaction.fromHex', () => {
+        txValid.forEach(f => {
+            // Objects that are only a single string are ignored
+            if (f.length === 1)
+                return;
+            const inputs = f[0];
+            const fhex = f[1];
+            //      const verifyFlags = f[2] // TODO: do we need to test this?
+            (0, mocha_1.it)('can decode ' + fhex, () => {
+                const transaction = bitcoin.Transaction.fromHex(fhex);
+                transaction.ins.forEach((txIn, i) => {
+                    const input = inputs[i];
+                    // reverse because test data is reversed
+                    const prevOutHash = Buffer.from(input[0], 'hex').reverse();
+                    const prevOutIndex = input[1];
+                    assert.deepStrictEqual(txIn.hash, prevOutHash);
+                    // we read UInt32, not Int32
+                    assert.strictEqual(txIn.index & 0xffffffff, prevOutIndex);
+                });
+            });
+        });
+    });
+    // sighash
+    (0, mocha_1.describe)('Transaction', () => {
+        sigHash.forEach(f => {
+            // Objects that are only a single string are ignored
+            if (f.length === 1)
+                return;
+            const txHex = f[0];
+            const scriptHex = f[1];
+            const inIndex = f[2];
+            const hashType = f[3];
+            const expectedHash = f[4];
+            const hashTypes = [];
+            if ((hashType & 0x1f) === bitcoin.Transaction.SIGHASH_NONE)
+                hashTypes.push('SIGHASH_NONE');
+            else if ((hashType & 0x1f) === bitcoin.Transaction.SIGHASH_SINGLE)
+                hashTypes.push('SIGHASH_SINGLE');
+            else
+                hashTypes.push('SIGHASH_ALL');
+            if (hashType & bitcoin.Transaction.SIGHASH_ANYONECANPAY)
+                hashTypes.push('SIGHASH_ANYONECANPAY');
+            const hashTypeName = hashTypes.join(' | ');
+            (0, mocha_1.it)('should hash ' +
+                txHex.slice(0, 40) +
+                '... (' +
+                hashTypeName +
+                ')', () => {
+                const transaction = bitcoin.Transaction.fromHex(txHex);
+                assert.strictEqual(transaction.toHex(), txHex);
+                const script = Buffer.from(scriptHex, 'hex');
+                const scriptChunks = bitcoin.script.decompile(script);
+                assert.strictEqual(bitcoin.script.compile(scriptChunks).toString('hex'), scriptHex);
+                const hash = transaction.hashForSignature(inIndex, script, hashType);
+                // reverse because test data is reversed
+                assert.strictEqual(hash.reverse().toString('hex'), expectedHash);
+                assert.doesNotThrow(() => transaction.hashForWitnessV0(inIndex, script, 0, 
+                // convert to UInt32
+                hashType < 0 ? 0x100000000 + hashType : hashType));
+            });
+        });
+    });
+    (0, mocha_1.describe)('script.signature.decode', () => {
+        sigCanonical.forEach(hex => {
+            const buffer = Buffer.from(hex, 'hex');
+            (0, mocha_1.it)('can parse ' + hex, () => {
+                const parsed = bitcoin.script.signature.decode(buffer);
+                const actual = bitcoin.script.signature.encode(parsed.signature, parsed.hashType);
+                assert.strictEqual(actual.toString('hex'), hex);
+            });
+        });
+        sigNoncanonical.forEach((hex, i) => {
+            if (i === 0)
+                return;
+            if (i % 2 !== 0)
+                return;
+            const description = sigNoncanonical[i - 1].slice(0, -1);
+            const buffer = Buffer.from(hex, 'hex');
+            (0, mocha_1.it)('throws on ' + description, () => {
+                const reg = new RegExp('Expected DER (integer|sequence)|(R|S) value (excessively ' +
+                    'padded|is negative)|(R|S|DER sequence) length is (zero|too ' +
+                    'short|too long|invalid)|Invalid hashType');
+                assert.throws(() => {
+                    bitcoin.script.signature.decode(buffer);
+                }, reg);
+            });
+        });
+    });
+});