@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/payments/{p2wsh.js → p2wsh.ts}

@@ -1,26 +1,23 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.p2wsh = void 0;
-const bcrypto = require('../crypto');
-const networks_1 = require('../networks');
-const bscript = require('../script');
-const types_1 = require('../types');
-const lazy = require('./lazy');
-const bech32_1 = require('bech32');
+import { bech32 } from 'bech32';
+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 * as lazy from './lazy.js';
+
 const OPS = bscript.OPS;
+
 const EMPTY_BUFFER = Buffer.alloc(0);
-function chunkHasUncompressedPubkey(chunk) {
-    if (
-        Buffer.isBuffer(chunk) &&
-        chunk.length === 65 &&
-        chunk[0] === 0x04 &&
-        (0, types_1.isPoint)(chunk)
-    ) {
+
+function chunkHasUncompressedPubkey(chunk: StackElement): boolean {
+    if (Buffer.isBuffer(chunk) && chunk.length === 65 && chunk[0] === 0x04 && isPoint(chunk)) {
         return true;
     } else {
         return false;
     }
 }
+
 // input: <>
 // witness: [redeemScriptSig ...] {redeemScript}
 // output: OP_0 {sha256(redeemScript)}
@@ -32,35 +29,35 @@ function chunkHasUncompressedPubkey(chunk) {
  * @returns The P2WSH payment object.
  * @throws {TypeError} If the required data is missing or invalid.
  */
-function p2wsh(a, opts) {
+export function p2wsh(a: Payment, opts?: PaymentOpts): Payment {
     if (!a.address && !a.hash && !a.output && !a.redeem && !a.witness)
         throw new TypeError('Not enough data');
     opts = Object.assign({ validate: true }, opts || {});
-    (0, types_1.typeforce)(
+
+    typef(
         {
-            network: types_1.typeforce.maybe(types_1.typeforce.Object),
-            address: types_1.typeforce.maybe(types_1.typeforce.String),
-            hash: types_1.typeforce.maybe(types_1.typeforce.BufferN(32)),
-            output: types_1.typeforce.maybe(types_1.typeforce.BufferN(34)),
-            redeem: types_1.typeforce.maybe({
-                input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
-                network: types_1.typeforce.maybe(types_1.typeforce.Object),
-                output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
-                witness: types_1.typeforce.maybe(
-                    types_1.typeforce.arrayOf(types_1.typeforce.Buffer),
-                ),
+            network: typef.maybe(typef.Object),
+
+            address: typef.maybe(typef.String),
+            hash: typef.maybe(typef.BufferN(32)),
+            output: typef.maybe(typef.BufferN(34)),
+
+            redeem: typef.maybe({
+                input: typef.maybe(typef.Buffer),
+                network: typef.maybe(typef.Object),
+                output: typef.maybe(typef.Buffer),
+                witness: typef.maybe(typef.arrayOf(typef.Buffer)),
             }),
-            input: types_1.typeforce.maybe(types_1.typeforce.BufferN(0)),
-            witness: types_1.typeforce.maybe(
-                types_1.typeforce.arrayOf(types_1.typeforce.Buffer),
-            ),
+            input: typef.maybe(typef.BufferN(0)),
+            witness: typef.maybe(typef.arrayOf(typef.Buffer)),
         },
         a,
     );
+
     const _address = lazy.value(() => {
-        const result = bech32_1.bech32.decode(a.address);
+        const result = bech32.decode(a.address!);
         const version = result.words.shift();
-        const data = bech32_1.bech32.fromWords(result.words);
+        const data = bech32.fromWords(result.words);
         return {
             version,
             prefix: result.prefix,
@@ -68,18 +65,21 @@ function p2wsh(a, opts) {
         };
     });
     const _rchunks = lazy.value(() => {
-        return bscript.decompile(a.redeem.input);
-    });
+        return bscript.decompile(a.redeem!.input!);
+    }) as StackFunction;
+
     let network = a.network;
     if (!network) {
-        network = (a.redeem && a.redeem.network) || networks_1.bitcoin;
+        network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
     }
-    const o = { network };
+
+    const o: Payment = { network };
+
     lazy.prop(o, 'address', () => {
         if (!o.hash) return;
-        const words = bech32_1.bech32.toWords(o.hash);
+        const words = bech32.toWords(o.hash);
         words.unshift(0x00);
-        return bech32_1.bech32.encode(network.bech32, words);
+        return bech32.encode(network!.bech32, words);
     });
     lazy.prop(o, 'hash', () => {
         if (a.output) return a.output.slice(2);
@@ -112,54 +112,52 @@ function p2wsh(a, opts) {
             a.redeem.output.length > 0
         ) {
             const stack = bscript.toStack(_rchunks());
+
             // assign, and blank the existing input
             o.redeem = Object.assign({ witness: stack }, a.redeem);
             o.redeem.input = EMPTY_BUFFER;
-            return [].concat(stack, a.redeem.output);
+            return ([] as Buffer[]).concat(stack, a.redeem.output);
         }
+
         if (!a.redeem) return;
         if (!a.redeem.output) return;
         if (!a.redeem.witness) return;
-        return [].concat(a.redeem.witness, a.redeem.output);
+        return ([] as Buffer[]).concat(a.redeem.witness, a.redeem.output);
     });
     lazy.prop(o, 'name', () => {
         const nameParts = ['p2wsh'];
-        if (o.redeem !== undefined && o.redeem.name !== undefined)
-            nameParts.push(o.redeem.name);
+        if (o.redeem !== undefined && o.redeem.name !== undefined) nameParts.push(o.redeem.name!);
         return nameParts.join('-');
     });
+
     // extended validation
     if (opts.validate) {
-        let hash = Buffer.from([]);
+        let hash: Buffer = Buffer.from([]);
         if (a.address) {
             if (_address().prefix !== network.bech32)
                 throw new TypeError('Invalid prefix or Network mismatch');
-            if (_address().version !== 0x00)
-                throw new TypeError('Invalid address version');
-            if (_address().data.length !== 32)
-                throw new TypeError('Invalid address data');
+            if (_address().version !== 0x00) throw new TypeError('Invalid address version');
+            if (_address().data.length !== 32) throw new TypeError('Invalid address data');
             hash = _address().data;
         }
+
         if (a.hash) {
-            if (hash.length > 0 && !hash.equals(a.hash))
-                throw new TypeError('Hash mismatch');
+            if (hash.length > 0 && !hash.equals(a.hash)) throw new TypeError('Hash mismatch');
             else hash = a.hash;
         }
+
         if (a.output) {
-            if (
-                a.output.length !== 34 ||
-                a.output[0] !== OPS.OP_0 ||
-                a.output[1] !== 0x20
-            )
+            if (a.output.length !== 34 || a.output[0] !== OPS.OP_0 || a.output[1] !== 0x20)
                 throw new TypeError('Output is invalid');
             const hash2 = a.output.slice(2);
-            if (hash.length > 0 && !hash.equals(hash2))
-                throw new TypeError('Hash mismatch');
+            if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
             else hash = hash2;
         }
+
         if (a.redeem) {
             if (a.redeem.network && a.redeem.network !== network)
                 throw new TypeError('Network mismatch');
+
             // is there two redeem sources?
             if (
                 a.redeem.input &&
@@ -168,59 +166,49 @@ function p2wsh(a, opts) {
                 a.redeem.witness.length > 0
             )
                 throw new TypeError('Ambiguous witness source');
+
             // is the redeem output non-empty/valid?
             if (a.redeem.output) {
                 const decompile = bscript.decompile(a.redeem.output);
                 if (!decompile || decompile.length < 1)
                     throw new TypeError('Redeem.output is invalid');
                 if (a.redeem.output.byteLength > 3600)
-                    throw new TypeError(
-                        'Redeem.output unspendable if larger than 3600 bytes',
-                    );
+                    throw new TypeError('Redeem.output unspendable if larger than 3600 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.sha256(a.redeem.output);
-                if (hash.length > 0 && !hash.equals(hash2))
-                    throw new TypeError('Hash mismatch');
+                if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
                 else hash = hash2;
             }
+
             if (a.redeem.input && !bscript.isPushOnly(_rchunks()))
                 throw new TypeError('Non push-only scriptSig');
-            if (
-                a.witness &&
-                a.redeem.witness &&
-                !(0, types_1.stacksEqual)(a.witness, a.redeem.witness)
-            )
+            if (a.witness && a.redeem.witness && !stacksEqual(a.witness, a.redeem.witness))
                 throw new TypeError('Witness and redeem.witness mismatch');
             if (
-                (a.redeem.input &&
-                    _rchunks().some(chunkHasUncompressedPubkey)) ||
+                (a.redeem.input && _rchunks().some(chunkHasUncompressedPubkey)) ||
                 (a.redeem.output &&
-                    (bscript.decompile(a.redeem.output) || []).some(
-                        chunkHasUncompressedPubkey,
-                    ))
+                    (bscript.decompile(a.redeem.output) || []).some(chunkHasUncompressedPubkey))
             ) {
-                throw new TypeError(
-                    'redeem.input or redeem.output contains uncompressed pubkey',
-                );
+                throw new TypeError('redeem.input or redeem.output contains uncompressed pubkey');
             }
         }
+
         if (a.witness && a.witness.length > 0) {
             const wScript = a.witness[a.witness.length - 1];
             if (a.redeem && a.redeem.output && !a.redeem.output.equals(wScript))
                 throw new TypeError('Witness and redeem.output mismatch');
             if (
                 a.witness.some(chunkHasUncompressedPubkey) ||
-                (bscript.decompile(wScript) || []).some(
-                    chunkHasUncompressedPubkey,
-                )
+                (bscript.decompile(wScript) || []).some(chunkHasUncompressedPubkey)
             )
                 throw new TypeError('Witness contains uncompressed pubkey');
         }
     }
+
     return Object.assign(o, a);
 }
-exports.p2wsh = p2wsh;