@btc-vision/bitcoin 6.3.6 → 6.4.1

package/src/psbt.ts

@@ -2,7 +2,6 @@ import { Psbt as PsbtBase } from 'bip174';
 import * as varuint from 'bip174/src/lib/converter/varint.js';
 import {
     Bip32Derivation,
-    Transaction as ITransaction,
     KeyValue,
     PartialSig,
     PsbtGlobal,
@@ -13,6 +12,7 @@ import {
     PsbtOutputUpdate,
     TapKeySig,
     TapScriptSig,
+    Transaction as ITransaction,
     TransactionFromBuffer,
 } from 'bip174/src/lib/interfaces.js';
 import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.js';
@@ -20,7 +20,6 @@ import { BIP32Interface } from 'bip32';
 import { ECPairInterface } from 'ecpair';
 import { fromOutputScript, toOutputScript } from './address.js';
 import { cloneBuffer, reverseBuffer } from './bufferutils.js';
-import { hookSigner } from './hooks/HookedSigner.js';
 import { payments } from './index.js';
 import { bitcoin as btcNetwork, Network } from './networks.js';
 import { tapleafHash } from './payments/bip341.js';
@@ -230,8 +229,7 @@ export class Psbt {
 
     clone(): Psbt {
         // TODO: more efficient cloning
-        const res = Psbt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
-        return res;
+        return Psbt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
     }
 
     setMaximumFeeRate(satoshiPerByte: number): void {
@@ -953,7 +951,7 @@ export class Psbt {
         keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): this {
-        hookSigner(keyPair);
+        //hookSigner(keyPair);
 
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
@@ -981,7 +979,7 @@ export class Psbt {
         tapLeafHashToSign?: Buffer,
         allowedSighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
     ): this {
-        hookSigner(keyPair);
+        //hookSigner(keyPair);
 
         const hashesForSig = this.checkTaprootHashesForSig(
             inputIndex,
@@ -1027,7 +1025,7 @@ export class Psbt {
         keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): Promise<void> {
-        hookSigner(keyPair);
+        //hookSigner(keyPair);
 
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
@@ -1056,7 +1054,7 @@ export class Psbt {
         tapLeafHash?: Buffer,
         sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
     ): Promise<void> {
-        hookSigner(keyPair);
+        //hookSigner(keyPair);
 
         const hashesForSig = this.checkTaprootHashesForSig(
             inputIndex,
@@ -1288,6 +1286,8 @@ function canFinalize(input: PsbtInput, script: Buffer, scriptType: string): bool
         case 'multisig':
             const p2ms = payments.p2ms({ output: script });
             return hasSigs(p2ms.m!, input.partialSig, p2ms.pubkeys);
+        case 'nonstandard':
+            return true;
         default:
             return false;
     }

package/test/address.spec.ts

@@ -1,13 +1,15 @@
-import * as assert from 'assert';
+import 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 * as baddress from '../src/address.js';
+import * as bscript from '../src/script.js';
+import fixtures from './fixtures/address.json' with { type: 'json' };
 
-import { initEccLib } from '../src';
+import { initEccLib, Network } from '../src/index.js';
 
-const NETWORKS = Object.assign(
+import * as networks from '../src/networks.js';
+
+const NETWORKS: Record<string, Network> = Object.assign(
     {
         litecoin: {
             messagePrefix: '\x19Litecoin Signed Message:\n',
@@ -20,12 +22,12 @@ const NETWORKS = Object.assign(
             wif: 0xb0,
         },
     },
-    require('../src/networks'),
+    networks,
 );
 
 describe('address', () => {
     describe('fromBase58Check', () => {
-        fixtures.standard.forEach(f => {
+        fixtures.standard.forEach((f) => {
             if (!f.base58check) return;
 
             it('decodes ' + f.base58check, () => {
@@ -36,17 +38,20 @@ describe('address', () => {
             });
         });
 
-        fixtures.invalid.fromBase58Check.forEach(f => {
+        fixtures.invalid.fromBase58Check.forEach((f) => {
             it('throws on ' + f.exception, () => {
-                assert.throws(() => {
-                    baddress.fromBase58Check(f.address);
-                }, new RegExp(f.address + ' ' + f.exception));
+                assert.throws(
+                    () => {
+                        baddress.fromBase58Check(f.address);
+                    },
+                    new RegExp(f.address + ' ' + f.exception),
+                );
             });
         });
     });
 
     describe('fromBech32', () => {
-        fixtures.standard.forEach(f => {
+        fixtures.standard.forEach((f) => {
             if (!f.bech32) return;
 
             it('decodes ' + f.bech32, () => {
@@ -58,61 +63,43 @@ describe('address', () => {
             });
         });
 
-        fixtures.invalid.bech32.forEach(f => {
-            it(
-                'decode fails for ' + f.address + '(' + f.exception + ')',
-                () => {
-                    assert.throws(() => {
-                        baddress.fromBech32(f.address);
-                    }, new RegExp(f.exception));
-                },
-            );
+        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.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));
-                },
-            );
+        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 => {
+        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,
-                );
+                const address = baddress.toBase58Check(Buffer.from(f.hash, 'hex'), f.version);
 
                 assert.strictEqual(address, f.base58check);
             });
@@ -120,7 +107,7 @@ describe('address', () => {
     });
 
     describe('toBech32', () => {
-        fixtures.bech32.forEach(f => {
+        fixtures.bech32.forEach((f) => {
             if (!f.address) return;
             const data = Buffer.from(f.data, 'hex');
 
@@ -134,40 +121,31 @@ describe('address', () => {
 
         // 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;
+            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,
-                    );
+                    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.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 => {
+        fixtures.invalid.toOutputScript.forEach((f) => {
             it('throws when ' + (f.exception || f.paymentException), () => {
-                const exception =
-                    f.paymentException || `${f.address} ${f.exception}`;
+                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.ts

@@ -1,26 +1,26 @@
-import * as assert from 'assert';
-import * as base58 from 'bs58';
+import assert from 'assert';
+import base58 from 'bs58';
 import { describe, it } from 'mocha';
-import * as bitcoin from '..';
-import * as base58EncodeDecode from './fixtures/core/base58_encode_decode.json';
-import * as base58KeysInvalid from './fixtures/core/base58_keys_invalid.json';
-import * as base58KeysValid from './fixtures/core/base58_keys_valid.json';
-import * as blocksValid from './fixtures/core/blocks.json';
-import * as sigCanonical from './fixtures/core/sig_canonical.json';
-import * as sigNoncanonical from './fixtures/core/sig_noncanonical.json';
-import * as sigHash from './fixtures/core/sighash.json';
-import * as txValid from './fixtures/core/tx_valid.json';
+import * as bitcoin from '../src/index.js';
+import base58EncodeDecode from './fixtures/core/base58_encode_decode.json' with { type: 'json' };
+import base58KeysInvalid from './fixtures/core/base58_keys_invalid.json' with { type: 'json' };
+import base58KeysValid from './fixtures/core/base58_keys_valid.json' with { type: 'json' };
+import blocksValid from './fixtures/core/blocks.json' with { type: 'json' };
+import sigCanonical from './fixtures/core/sig_canonical.json' with { type: 'json' };
+import sigNoncanonical from './fixtures/core/sig_noncanonical.json' with { type: 'json' };
+import sigHash from './fixtures/core/sighash.json' with { type: 'json' };
+import txValid from './fixtures/core/tx_valid.json' with { type: 'json' };
 
 describe('Bitcoin-core', () => {
     // base58EncodeDecode
     describe('base58', () => {
-        base58EncodeDecode.forEach(f => {
+        base58EncodeDecode.forEach((f) => {
             const fhex = f[0];
             const fb58 = f[1];
 
             it('can decode ' + fb58, () => {
                 const buffer = base58.decode(fb58);
-                const actual = buffer.toString('hex');
+                const actual = Buffer.from(buffer).toString('hex');
 
                 assert.strictEqual(actual, fhex);
             });
@@ -41,7 +41,7 @@ describe('Bitcoin-core', () => {
             script: 'scriptHash',
         };
 
-        base58KeysValid.forEach(f => {
+        base58KeysValid.forEach((f) => {
             const expected = f[0];
             const hash = Buffer.from(f[1] as any, 'hex');
             const params = f[2] as any;
@@ -51,13 +51,11 @@ describe('Bitcoin-core', () => {
             const network: any = params.isTestnet
                 ? bitcoin.networks.testnet
                 : bitcoin.networks.bitcoin;
+
             const version = network[typeMap[params.addrType]];
 
-            it('can export ' + expected, () => {
-                assert.strictEqual(
-                    bitcoin.address.toBase58Check(hash, version),
-                    expected,
-                );
+            it(`can export ${expected as string}`, () => {
+                assert.strictEqual(bitcoin.address.toBase58Check(hash, version), expected);
             });
         });
     });
@@ -71,7 +69,7 @@ describe('Bitcoin-core', () => {
             bitcoin.networks.testnet.scriptHash,
         ];
 
-        base58KeysInvalid.forEach(f => {
+        base58KeysInvalid.forEach((f) => {
             const strng = f[0];
 
             it('throws on ' + strng, () => {
@@ -89,7 +87,7 @@ describe('Bitcoin-core', () => {
     });
 
     describe('Block.fromHex', () => {
-        blocksValid.forEach(f => {
+        blocksValid.forEach((f) => {
             it('can parse ' + f.id, () => {
                 const block = bitcoin.Block.fromHex(f.hex);
 
@@ -101,7 +99,7 @@ describe('Bitcoin-core', () => {
 
     // txValid
     describe('Transaction.fromHex', () => {
-        txValid.forEach(f => {
+        txValid.forEach((f) => {
             // Objects that are only a single string are ignored
             if (f.length === 1) return;
 
@@ -116,10 +114,7 @@ describe('Bitcoin-core', () => {
                     const input = inputs[i];
 
                     // reverse because test data is reversed
-                    const prevOutHash = Buffer.from(
-                        input[0] as string,
-                        'hex',
-                    ).reverse();
+                    const prevOutHash = Buffer.from(input[0] as string, 'hex').reverse();
                     const prevOutIndex = input[1];
 
                     assert.deepStrictEqual(txIn.hash, prevOutHash);
@@ -133,7 +128,7 @@ describe('Bitcoin-core', () => {
 
     // sighash
     describe('Transaction', () => {
-        sigHash.forEach(f => {
+        sigHash.forEach((f) => {
             // Objects that are only a single string are ignored
             if (f.length === 1) return;
 
@@ -154,59 +149,42 @@ describe('Bitcoin-core', () => {
 
             const hashTypeName = hashTypes.join(' | ');
 
-            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,
-                    );
+            it('should hash ' + txHex.slice(0, 40) + '... (' + hashTypeName + ')', () => {
+                const transaction = bitcoin.Transaction.fromHex(txHex);
+                assert.strictEqual(transaction.toHex(), txHex);
 
-                    const hash = transaction.hashForSignature(
-                        inIndex,
-                        script,
-                        hashType,
-                    );
+                const script = Buffer.from(scriptHex, 'hex');
+                const scriptChunks = bitcoin.script.decompile(script);
+                assert.strictEqual(
+                    bitcoin.script.compile(scriptChunks!).toString('hex'),
+                    scriptHex,
+                );
 
-                    // reverse because test data is reversed
-                    assert.strictEqual(
-                        (hash.reverse() as Buffer).toString('hex'),
-                        expectedHash,
-                    );
+                const hash = transaction.hashForSignature(inIndex, script, hashType);
 
-                    assert.doesNotThrow(() =>
-                        transaction.hashForWitnessV0(
-                            inIndex,
-                            script,
-                            0,
-                            // convert to UInt32
-                            hashType < 0 ? 0x100000000 + hashType : hashType,
-                        ),
-                    );
-                },
-            );
+                // reverse because test data is reversed
+                assert.strictEqual((hash.reverse() as Buffer).toString('hex'), expectedHash);
+
+                assert.doesNotThrow(() =>
+                    transaction.hashForWitnessV0(
+                        inIndex,
+                        script,
+                        0,
+                        // convert to UInt32
+                        hashType < 0 ? 0x100000000 + hashType : hashType,
+                    ),
+                );
+            });
         });
     });
 
     describe('script.signature.decode', () => {
-        sigCanonical.forEach(hex => {
+        sigCanonical.forEach((hex) => {
             const buffer = Buffer.from(hex, 'hex');
 
             it('can parse ' + hex, () => {
                 const parsed = bitcoin.script.signature.decode(buffer);
-                const actual = bitcoin.script.signature.encode(
-                    parsed.signature,
-                    parsed.hashType,
-                );
+                const actual = bitcoin.script.signature.encode(parsed.signature, parsed.hashType);
 
                 assert.strictEqual(actual.toString('hex'), hex);
             });

package/test/block.spec.ts

@@ -1,8 +1,8 @@
-import * as assert from 'assert';
+import assert from 'assert';
 import { beforeEach, describe, it } from 'mocha';
-import { Block } from '..';
+import { Block } from '../src/index.js';
 
-import * as fixtures from './fixtures/block.json';
+import fixtures from './fixtures/block.json' with { type: 'json' };
 
 describe('Block', () => {
     describe('version', () => {
@@ -18,34 +18,25 @@ describe('Block', () => {
     });
 
     describe('calculateTarget', () => {
-        fixtures.targets.forEach(f => {
+        fixtures.targets.forEach((f) => {
             it('returns ' + f.expected + ' for 0x' + f.bits, () => {
                 const bits = parseInt(f.bits, 16);
 
-                assert.strictEqual(
-                    Block.calculateTarget(bits).toString('hex'),
-                    f.expected,
-                );
+                assert.strictEqual(Block.calculateTarget(bits).toString('hex'), f.expected);
             });
         });
     });
 
     describe('fromBuffer/fromHex', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             it('imports ' + f.description, () => {
                 const block = Block.fromHex(f.hex);
 
                 assert.strictEqual(block.version, f.version);
                 assert.strictEqual(block.prevHash!.toString('hex'), f.prevHash);
-                assert.strictEqual(
-                    block.merkleRoot!.toString('hex'),
-                    f.merkleRoot,
-                );
+                assert.strictEqual(block.merkleRoot!.toString('hex'), f.merkleRoot);
                 if (block.witnessCommit) {
-                    assert.strictEqual(
-                        block.witnessCommit.toString('hex'),
-                        f.witnessCommit,
-                    );
+                    assert.strictEqual(block.witnessCommit.toString('hex'), f.witnessCommit);
                 }
                 assert.strictEqual(block.timestamp, f.timestamp);
                 assert.strictEqual(block.bits, f.bits);
@@ -53,16 +44,13 @@ describe('Block', () => {
                 assert.strictEqual(!block.transactions, f.hex.length === 160);
                 if (f.size && f.strippedSize && f.weight) {
                     assert.strictEqual(block.byteLength(false, true), f.size);
-                    assert.strictEqual(
-                        block.byteLength(false, false),
-                        f.strippedSize,
-                    );
+                    assert.strictEqual(block.byteLength(false, false), f.strippedSize);
                     assert.strictEqual(block.weight(), f.weight);
                 }
             });
         });
 
-        fixtures.invalid.forEach(f => {
+        fixtures.invalid.forEach((f) => {
             it('throws on ' + f.exception, () => {
                 assert.throws(() => {
                     Block.fromHex(f.hex);
@@ -72,7 +60,7 @@ describe('Block', () => {
     });
 
     describe('toBuffer/toHex', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             let block: Block;
 
             beforeEach(() => {
@@ -87,7 +75,7 @@ describe('Block', () => {
     });
 
     describe('getHash/getId', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             let block: Block;
 
             beforeEach(() => {
@@ -102,7 +90,7 @@ describe('Block', () => {
     });
 
     describe('getUTCDate', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             let block: Block;
 
             beforeEach(() => {
@@ -124,7 +112,7 @@ describe('Block', () => {
             }, /Cannot compute merkle root for zero transactions/);
         });
 
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             if (f.hex.length === 160) return;
 
             let block: Block;
@@ -135,35 +123,24 @@ describe('Block', () => {
 
             it('returns ' + f.merkleRoot + ' for ' + f.id, () => {
                 assert.strictEqual(
-                    Block.calculateMerkleRoot(block.transactions!).toString(
-                        'hex',
-                    ),
+                    Block.calculateMerkleRoot(block.transactions!).toString('hex'),
                     f.merkleRoot,
                 );
             });
 
             if (f.witnessCommit) {
-                it(
-                    'returns witness commit ' +
-                        f.witnessCommit +
-                        ' for ' +
-                        f.id,
-                    () => {
-                        assert.strictEqual(
-                            Block.calculateMerkleRoot(
-                                block.transactions!,
-                                true,
-                            ).toString('hex'),
-                            f.witnessCommit,
-                        );
-                    },
-                );
+                it('returns witness commit ' + f.witnessCommit + ' for ' + f.id, () => {
+                    assert.strictEqual(
+                        Block.calculateMerkleRoot(block.transactions!, true).toString('hex'),
+                        f.witnessCommit,
+                    );
+                });
             }
         });
     });
 
     describe('checkTxRoots', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             if (f.hex.length === 160) return;
 
             let block: Block;
@@ -179,7 +156,7 @@ describe('Block', () => {
     });
 
     describe('checkProofOfWork', () => {
-        fixtures.valid.forEach(f => {
+        fixtures.valid.forEach((f) => {
             let block: Block;
 
             beforeEach(() => {