@btc-vision/bitcoin 6.4.2 → 6.4.3

package/src/payments/p2sh.ts

@@ -1,206 +1,211 @@
-import * as bs58check from 'bs58check';
-import * as bcrypto from '../crypto.js';
-import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
-import * as bscript from '../script.js';
-import { stacksEqual, typeforce as typef } from '../types.js';
-import { Payment, PaymentFunction, PaymentOpts, Stack, StackFunction } from './index.js';
-import * as lazy from './lazy.js';
-
-const OPS = bscript.OPS;
-
-// input: [redeemScriptSig ...] {redeemScript}
-// witness: <?>
-// output: OP_HASH160 {hash160(redeemScript)} OP_EQUAL
-/**
- * Creates a Pay-to-Script-Hash (P2SH) payment object.
- *
- * @param a - The payment object containing the necessary data.
- * @param opts - Optional payment options.
- * @returns The P2SH payment object.
- * @throws {TypeError} If the required data is not provided or if the data is invalid.
- */
-export function p2sh(a: Payment, opts?: PaymentOpts): Payment {
-    if (!a.address && !a.hash && !a.output && !a.redeem && !a.input) {
-        throw new TypeError('Not enough data');
-    }
-    opts = Object.assign({ validate: true }, opts || {});
-
-    typef(
-        {
-            network: typef.maybe(typef.Object),
-
-            address: typef.maybe(typef.String),
-            hash: typef.maybe(typef.BufferN(20)),
-            output: typef.maybe(typef.BufferN(23)),
-
-            redeem: typef.maybe({
-                network: typef.maybe(typef.Object),
-                output: typef.maybe(typef.Buffer),
-                input: typef.maybe(typef.Buffer),
-                witness: typef.maybe(typef.arrayOf(typef.Buffer)),
-            }),
-            input: typef.maybe(typef.Buffer),
-            witness: typef.maybe(typef.arrayOf(typef.Buffer)),
-        },
-        a,
-    );
-
-    let network = a.network;
-    if (!network) {
-        network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
-    }
-
-    const o: Payment = { network };
-
-    const _address = lazy.value(() => {
-        const payload = Buffer.from(bs58check.default.decode(a.address!));
-        const version = payload.readUInt8(0);
-        const hash = payload.slice(1);
-        return { version, hash };
-    });
-    const _chunks = lazy.value(() => {
-        return bscript.decompile(a.input!);
-    }) as StackFunction;
-    const _redeem = lazy.value((): Payment => {
-        const chunks = _chunks();
-        const lastChunk = chunks[chunks.length - 1];
-        return {
-            network,
-            output: lastChunk === OPS.OP_FALSE ? Buffer.from([]) : (lastChunk as Buffer),
-            input: bscript.compile(chunks.slice(0, -1)),
-            witness: a.witness || [],
-        };
-    }) as PaymentFunction;
-
-    // output dependents
-    lazy.prop(o, 'address', () => {
-        if (!o.hash) return;
-
-        const payload = Buffer.allocUnsafe(21);
-        payload.writeUInt8(o.network!.scriptHash, 0);
-        o.hash.copy(payload, 1);
-        return bs58check.default.encode(payload);
-    });
-    lazy.prop(o, 'hash', () => {
-        // in order of least effort
-        if (a.output) return a.output.slice(2, 22);
-        if (a.address) return _address().hash;
-        if (o.redeem && o.redeem.output) return bcrypto.hash160(o.redeem.output);
-    });
-    lazy.prop(o, 'output', () => {
-        if (!o.hash) return;
-        return bscript.compile([OPS.OP_HASH160, o.hash, OPS.OP_EQUAL]);
-    });
-
-    // input dependents
-    lazy.prop(o, 'redeem', () => {
-        if (!a.input) return;
-        return _redeem();
-    });
-    lazy.prop(o, 'input', () => {
-        if (!a.redeem || !a.redeem.input || !a.redeem.output) return;
-        return bscript.compile(
-            ([] as Stack).concat(bscript.decompile(a.redeem.input) as Stack, a.redeem.output),
-        );
-    });
-    lazy.prop(o, 'witness', () => {
-        if (o.redeem && o.redeem.witness) return o.redeem.witness;
-        if (o.input) return [];
-    });
-    lazy.prop(o, 'name', () => {
-        const nameParts = ['p2sh'];
-        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name!);
-        return nameParts.join('-');
-    });
-
-    if (opts.validate) {
-        let hash: Buffer = Buffer.from([]);
-        if (a.address) {
-            if (_address().version !== network.scriptHash)
-                throw new TypeError('Invalid version or Network mismatch');
-            if (_address().hash.length !== 20) throw new TypeError('Invalid address');
-            hash = _address().hash;
-        }
-
-        if (a.hash) {
-            if (hash.length > 0 && !hash.equals(a.hash)) throw new TypeError('Hash mismatch');
-            else hash = a.hash;
-        }
-
-        if (a.output) {
-            if (
-                a.output.length !== 23 ||
-                a.output[0] !== OPS.OP_HASH160 ||
-                a.output[1] !== 0x14 ||
-                a.output[22] !== OPS.OP_EQUAL
-            )
-                throw new TypeError('Output is invalid');
-
-            const hash2 = a.output.slice(2, 22);
-            if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
-            else hash = hash2;
-        }
-
-        // inlined to prevent 'no-inner-declarations' failing
-        const checkRedeem = (redeem: Payment): void => {
-            // is the redeem output empty/invalid?
-            if (redeem.output) {
-                const decompile = bscript.decompile(redeem.output);
-                if (!decompile || decompile.length < 1)
-                    throw new TypeError('Redeem.output too short');
-                if (redeem.output.byteLength > 520)
-                    throw new TypeError('Redeem.output unspendable if larger than 520 bytes');
-                if (bscript.countNonPushOnlyOPs(decompile) > 201)
-                    throw new TypeError(
-                        'Redeem.output unspendable with more than 201 non-push ops',
-                    );
-
-                // match hash against other sources
-                const hash2 = bcrypto.hash160(redeem.output);
-                if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
-                else hash = hash2;
-            }
-
-            if (redeem.input) {
-                const hasInput = redeem.input.length > 0;
-                const hasWitness = redeem.witness && redeem.witness.length > 0;
-                if (!hasInput && !hasWitness) throw new TypeError('Empty input');
-                if (hasInput && hasWitness) throw new TypeError('Input and witness provided');
-                if (hasInput) {
-                    const richunks = bscript.decompile(redeem.input) as Stack;
-                    if (!bscript.isPushOnly(richunks))
-                        throw new TypeError('Non push-only scriptSig');
-                }
-            }
-        };
-
-        if (a.input) {
-            const chunks = _chunks();
-            if (!chunks || chunks.length < 1) throw new TypeError('Input too short');
-            if (!Buffer.isBuffer(_redeem().output)) throw new TypeError('Input is invalid');
-
-            checkRedeem(_redeem());
-        }
-
-        if (a.redeem) {
-            if (a.redeem.network && a.redeem.network !== network)
-                throw new TypeError('Network mismatch');
-            if (a.input) {
-                const redeem = _redeem();
-                if (a.redeem.output && !a.redeem.output.equals(redeem.output!))
-                    throw new TypeError('Redeem.output mismatch');
-                if (a.redeem.input && !a.redeem.input.equals(redeem.input!))
-                    throw new TypeError('Redeem.input mismatch');
-            }
-
-            checkRedeem(a.redeem);
-        }
-
-        if (a.witness) {
-            if (a.redeem && a.redeem.witness && !stacksEqual(a.redeem.witness, a.witness))
-                throw new TypeError('Witness and redeem.witness mismatch');
-        }
-    }
-
-    return Object.assign(o, a);
-}
+import * as bs58check from 'bs58check';
+import * as bcrypto from '../crypto.js';
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { stacksEqual, typeforce as typef } from '../types.js';
+import { P2SHPayment, Payment, PaymentOpts, ScriptRedeem, Stack, StackFunction } from './index.js';
+import * as lazy from './lazy.js';
+
+const OPS = bscript.OPS;
+
+// input: [redeemScriptSig ...] {redeemScript}
+// witness: <?>
+// output: OP_HASH160 {hash160(redeemScript)} OP_EQUAL
+/**
+ * Creates a Pay-to-Script-Hash (P2SH) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2SH payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+export function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPayment {
+    if (!a.address && !a.hash && !a.output && !a.redeem && !a.input) {
+        throw new TypeError('Not enough data');
+    }
+    opts = Object.assign({ validate: true }, opts || {});
+
+    typef(
+        {
+            network: typef.maybe(typef.Object),
+
+            address: typef.maybe(typef.String),
+            hash: typef.maybe(typef.BufferN(20)),
+            output: typef.maybe(typef.BufferN(23)),
+
+            redeem: typef.maybe({
+                network: typef.maybe(typef.Object),
+                output: typef.maybe(typef.Buffer),
+                input: typef.maybe(typef.Buffer),
+                witness: typef.maybe(typef.arrayOf(typef.Buffer)),
+            }),
+            input: typef.maybe(typef.Buffer),
+            witness: typef.maybe(typef.arrayOf(typef.Buffer)),
+        },
+        a,
+    );
+
+    let network = a.network;
+    if (!network) {
+        network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
+    }
+
+    const o: P2SHPayment = {
+        network,
+        name: 'p2sh',
+        hash: undefined,
+    };
+
+    const _address = lazy.value(() => {
+        const payload = Buffer.from(bs58check.default.decode(a.address!));
+        const version = payload.readUInt8(0);
+        const hash = payload.slice(1);
+        return { version, hash };
+    });
+    const _chunks = lazy.value(() => {
+        return bscript.decompile(a.input!);
+    }) as StackFunction;
+
+    const _redeem = lazy.value((): ScriptRedeem => {
+        const chunks = _chunks();
+        const lastChunk = chunks[chunks.length - 1];
+        return {
+            network,
+            output: lastChunk === OPS.OP_FALSE ? Buffer.from([]) : (lastChunk as Buffer),
+            input: bscript.compile(chunks.slice(0, -1)),
+            witness: a.witness || [],
+        };
+    });
+
+    // output dependents
+    lazy.prop(o, 'address', () => {
+        if (!o.hash) return;
+
+        const payload = Buffer.allocUnsafe(21);
+        payload.writeUInt8(o.network!.scriptHash, 0);
+        o.hash.copy(payload, 1);
+        return bs58check.default.encode(payload);
+    });
+    lazy.prop(o, 'hash', () => {
+        // in order of least effort
+        if (a.output) return a.output.slice(2, 22);
+        if (a.address) return _address().hash;
+        if (o.redeem && o.redeem.output) return bcrypto.hash160(o.redeem.output);
+    });
+    lazy.prop(o, 'output', () => {
+        if (!o.hash) return;
+        return bscript.compile([OPS.OP_HASH160, o.hash, OPS.OP_EQUAL]);
+    });
+
+    // input dependents
+    lazy.prop(o, 'redeem', () => {
+        if (!a.input) return;
+        return _redeem();
+    });
+    lazy.prop(o, 'input', () => {
+        if (!a.redeem || !a.redeem.input || !a.redeem.output) return;
+        return bscript.compile(
+            ([] as Stack).concat(bscript.decompile(a.redeem.input) as Stack, a.redeem.output),
+        );
+    });
+    lazy.prop(o, 'witness', () => {
+        if (o.redeem && o.redeem.witness) return o.redeem.witness;
+        if (o.input) return [];
+    });
+    lazy.prop(o, 'name', () => {
+        const nameParts = ['p2sh'];
+        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name!);
+        return nameParts.join('-');
+    });
+
+    if (opts.validate) {
+        let hash: Buffer = Buffer.from([]);
+        if (a.address) {
+            if (_address().version !== network.scriptHash)
+                throw new TypeError('Invalid version or Network mismatch');
+            if (_address().hash.length !== 20) throw new TypeError('Invalid address');
+            hash = _address().hash;
+        }
+
+        if (a.hash) {
+            if (hash.length > 0 && !hash.equals(a.hash)) throw new TypeError('Hash mismatch');
+            else hash = a.hash;
+        }
+
+        if (a.output) {
+            if (
+                a.output.length !== 23 ||
+                a.output[0] !== OPS.OP_HASH160 ||
+                a.output[1] !== 0x14 ||
+                a.output[22] !== OPS.OP_EQUAL
+            )
+                throw new TypeError('Output is invalid');
+
+            const hash2 = a.output.slice(2, 22);
+            if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
+            else hash = hash2;
+        }
+
+        // inlined to prevent 'no-inner-declarations' failing
+        const checkRedeem = (redeem: Payment): void => {
+            // is the redeem output empty/invalid?
+            if (redeem.output) {
+                const decompile = bscript.decompile(redeem.output);
+                if (!decompile || decompile.length < 1)
+                    throw new TypeError('Redeem.output too short');
+                if (redeem.output.byteLength > 520)
+                    throw new TypeError('Redeem.output unspendable if larger than 520 bytes');
+                if (bscript.countNonPushOnlyOPs(decompile) > 201)
+                    throw new TypeError(
+                        'Redeem.output unspendable with more than 201 non-push ops',
+                    );
+
+                // match hash against other sources
+                const hash2 = bcrypto.hash160(redeem.output);
+                if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
+                else hash = hash2;
+            }
+
+            if (redeem.input) {
+                const hasInput = redeem.input.length > 0;
+                const hasWitness = redeem.witness && redeem.witness.length > 0;
+                if (!hasInput && !hasWitness) throw new TypeError('Empty input');
+                if (hasInput && hasWitness) throw new TypeError('Input and witness provided');
+                if (hasInput) {
+                    const richunks = bscript.decompile(redeem.input) as Stack;
+                    if (!bscript.isPushOnly(richunks))
+                        throw new TypeError('Non push-only scriptSig');
+                }
+            }
+        };
+
+        if (a.input) {
+            const chunks = _chunks();
+            if (!chunks || chunks.length < 1) throw new TypeError('Input too short');
+            if (!Buffer.isBuffer(_redeem().output)) throw new TypeError('Input is invalid');
+
+            checkRedeem(_redeem());
+        }
+
+        if (a.redeem) {
+            if (a.redeem.network && a.redeem.network !== network)
+                throw new TypeError('Network mismatch');
+            if (a.input) {
+                const redeem = _redeem();
+                if (a.redeem.output && !a.redeem.output.equals(redeem.output!))
+                    throw new TypeError('Redeem.output mismatch');
+                if (a.redeem.input && !a.redeem.input.equals(redeem.input!))
+                    throw new TypeError('Redeem.input mismatch');
+            }
+
+            checkRedeem(a.redeem);
+        }
+
+        if (a.witness) {
+            if (a.redeem && a.redeem.witness && !stacksEqual(a.redeem.witness, a.witness))
+                throw new TypeError('Witness and redeem.witness mismatch');
+        }
+    }
+
+    return Object.assign(o, a);
+}

package/src/payments/p2tr.ts

@@ -13,7 +13,7 @@ import {
     toHashTree,
     tweakKey,
 } from './bip341.js';
-import { Payment, PaymentOpts } from './index.js';
+import { P2TRPayment, PaymentOpts } from './index.js';
 import * as lazy from './lazy.js';
 
 const OPS = bscript.OPS;
@@ -28,7 +28,7 @@ const ANNEX_PREFIX = 0x50;
  * @returns The P2TR payment object.
  * @throws {TypeError} If the provided data is invalid or insufficient.
  */
-export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
+export function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPayment {
     if (
         !a.address &&
         !a.output &&
@@ -82,7 +82,10 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
     });
 
     const network = a.network || BITCOIN_NETWORK;
-    const o: Payment = { name: 'p2tr', network };
+    const o: P2TRPayment = {
+        name: 'p2tr',
+        network,
+    };
 
     lazy.prop(o, 'address', () => {
         if (!o.pubkey) return;
@@ -95,6 +98,7 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
     lazy.prop(o, 'hash', () => {
         const hashTree = _hashTree();
         if (hashTree) return hashTree.hash;
+
         const w = _witness();
         if (w && w.length > 1) {
             const controlBlock = w[w.length - 1];
@@ -106,7 +110,8 @@ export function p2tr(a: Payment, opts?: PaymentOpts): Payment {
             });
             return rootHashFromPath(controlBlock, leafHash);
         }
-        return null;
+
+        return undefined;
     });
     lazy.prop(o, 'output', () => {
         if (!o.pubkey) return;

package/src/payments/p2wpkh.ts

@@ -3,7 +3,7 @@ import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { isPoint, typeforce as typef } from '../types.js';
-import { Payment, PaymentOpts } from './index.js';
+import { P2WPKHPayment, PaymentOpts } from './index.js';
 import * as lazy from './lazy.js';
 
 const OPS = bscript.OPS;
@@ -21,7 +21,7 @@ const EMPTY_BUFFER = Buffer.alloc(0);
  * @returns The p2wpkh payment object.
  * @throws {TypeError} If the required data is missing or invalid.
  */
-export function p2wpkh(a: Payment, opts?: PaymentOpts): Payment {
+export function p2wpkh(a: Omit<P2WPKHPayment, 'name'>, opts?: PaymentOpts): P2WPKHPayment {
     if (!a.address && !a.hash && !a.output && !a.pubkey && !a.witness)
         throw new TypeError('Not enough data');
     opts = Object.assign({ validate: true }, opts || {});
@@ -52,7 +52,11 @@ export function p2wpkh(a: Payment, opts?: PaymentOpts): Payment {
     });
 
     const network = a.network || BITCOIN_NETWORK;
-    const o: Payment = { name: 'p2wpkh', network };
+    const o: P2WPKHPayment = {
+        name: 'p2wpkh',
+        network,
+        hash: undefined,
+    };
 
     lazy.prop(o, 'address', () => {
         if (!o.hash) return;

package/src/payments/p2wsh.ts

@@ -3,7 +3,7 @@ import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
-import { Payment, PaymentOpts, StackElement, StackFunction } from './index.js';
+import { P2WSHPayment, PaymentOpts, StackElement, StackFunction } from './index.js';
 import * as lazy from './lazy.js';
 
 const OPS = bscript.OPS;
@@ -29,7 +29,7 @@ function chunkHasUncompressedPubkey(chunk: StackElement): boolean {
  * @returns The P2WSH payment object.
  * @throws {TypeError} If the required data is missing or invalid.
  */
-export function p2wsh(a: Payment, opts?: PaymentOpts): Payment {
+export function p2wsh(a: Omit<P2WSHPayment, 'name'>, opts?: PaymentOpts): P2WSHPayment {
     if (!a.address && !a.hash && !a.output && !a.redeem && !a.witness)
         throw new TypeError('Not enough data');
     opts = Object.assign({ validate: true }, opts || {});
@@ -73,7 +73,11 @@ export function p2wsh(a: Payment, opts?: PaymentOpts): Payment {
         network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
     }
 
-    const o: Payment = { network };
+    const o: P2WSHPayment = {
+        network,
+        name: 'p2wsh',
+        hash: undefined,
+    };
 
     lazy.prop(o, 'address', () => {
         if (!o.hash) return;

package/src/psbt.ts

@@ -23,7 +23,7 @@ import { cloneBuffer, reverseBuffer } from './bufferutils.js';
 import { payments } from './index.js';
 import { bitcoin as btcNetwork, Network } from './networks.js';
 import { tapleafHash } from './payments/bip341.js';
-import { Payment, PaymentOpts } from './payments/index.js';
+import { P2SHPayment, Payment, PaymentOpts } from './payments/index.js';
 import {
     checkTaprootInputFields,
     checkTaprootInputForSigs,
@@ -1284,7 +1284,9 @@ function canFinalize(input: PsbtInput, script: Buffer, scriptType: string): bool
         case 'witnesspubkeyhash':
             return hasSigs(1, input.partialSig);
         case 'multisig':
-            const p2ms = payments.p2ms({ output: script });
+            const p2ms = payments.p2ms({
+                output: script,
+            });
             return hasSigs(p2ms.m!, input.partialSig, p2ms.pubkeys);
         case 'nonstandard':
             return true;
@@ -1412,7 +1414,7 @@ function scriptCheckerFactory(
     ): void => {
         const redeemScriptOutput = payment({
             redeem: { output: redeemScript },
-        }).output as Buffer;
+        } as P2SHPayment).output as Buffer;
 
         if (!scriptPubKey.equals(redeemScriptOutput)) {
             throw new Error(

package/test/payments.spec.ts

@@ -4,7 +4,7 @@ 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';
+import { p2pk, P2SHPayment, p2wsh } from '../src/payments/index.js';
 
 const require = async (name: string) => {
     const mod = await import(name);
@@ -68,7 +68,7 @@ const require = async (name: string) => {
                             ),
                         }),
                     }),
-                });
+                } as P2SHPayment);
                 assert.strictEqual(actual.address, '3MGbrbye4ttNUXM8WAvBFRKry4fkS9fjuw');
                 assert.strictEqual(actual.name, 'p2sh-p2wsh-p2pk');
                 assert.strictEqual(actual.redeem!.name, 'p2wsh-p2pk');