@btc-vision/bitcoin 6.3.1 → 6.3.2

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

@@ -1,13 +1,13 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.p2sh = 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 bs58check = require('bs58check');
+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
@@ -19,74 +19,78 @@ const OPS = bscript.OPS;
  * @returns The P2SH payment object.
  * @throws {TypeError} If the required data is not provided or if the data is invalid.
  */
-function p2sh(a, opts) {
+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 || {});
-    (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(20)),
-            output: types_1.typeforce.maybe(types_1.typeforce.BufferN(23)),
-            redeem: types_1.typeforce.maybe({
-                network: types_1.typeforce.maybe(types_1.typeforce.Object),
-                output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
-                input: 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(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: types_1.typeforce.maybe(types_1.typeforce.Buffer),
-            witness: types_1.typeforce.maybe(
-                types_1.typeforce.arrayOf(types_1.typeforce.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) || networks_1.bitcoin;
+        network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
     }
-    const o = { network };
+
+    const o: Payment = { network };
+
     const _address = lazy.value(() => {
-        const payload = Buffer.from(bs58check.decode(a.address));
+        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);
-    });
-    const _redeem = 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,
+            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);
+        payload.writeUInt8(o.network!.scriptHash, 0);
         o.hash.copy(payload, 1);
-        return bs58check.encode(payload);
+        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);
+        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;
@@ -95,7 +99,7 @@ function p2sh(a, opts) {
     lazy.prop(o, 'input', () => {
         if (!a.redeem || !a.redeem.input || !a.redeem.output) return;
         return bscript.compile(
-            [].concat(bscript.decompile(a.redeem.input), a.redeem.output),
+            ([] as Stack).concat(bscript.decompile(a.redeem.input) as Stack, a.redeem.output),
         );
     });
     lazy.prop(o, 'witness', () => {
@@ -104,24 +108,24 @@ function p2sh(a, opts) {
     });
     lazy.prop(o, 'name', () => {
         const nameParts = ['p2sh'];
-        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('-');
     });
+
     if (opts.validate) {
-        let hash = Buffer.from([]);
+        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');
+            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');
+            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 ||
@@ -130,75 +134,72 @@ function p2sh(a, opts) {
                 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');
+            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 => {
+        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',
-                    );
+                    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');
+                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 && !hasWitness) throw new TypeError('Empty input');
+                if (hasInput && hasWitness) throw new TypeError('Input and witness provided');
                 if (hasInput) {
-                    const richunks = bscript.decompile(redeem.input);
+                    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');
+            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))
+                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))
+                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 &&
-                !(0, types_1.stacksEqual)(a.redeem.witness, 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);
 }
-exports.p2sh = p2sh;