@btc-vision/bitcoin 6.5.1 → 6.5.2

package/build/psbt/psbtutils.js

@@ -18,7 +18,7 @@ function isPaymentFactory(payment) {
             payment({ output: script });
             return true;
         }
-        catch (err) {
+        catch {
             return false;
         }
     };
@@ -170,14 +170,15 @@ export function signatureBlocksAction(signature, signatureDecodeFn, action) {
     return whitelist.indexOf(action) === -1;
 }
 function extractPartialSigs(input) {
-    let pSigs = [];
-    if ((input.partialSig || []).length === 0) {
+    const { partialSig } = input;
+    let pSigs;
+    if (!partialSig || partialSig.length === 0) {
         if (!input.finalScriptSig && !input.finalScriptWitness)
             return [];
         pSigs = getPsigsFromInputFinalScripts(input);
     }
     else {
-        pSigs = input.partialSig;
+        pSigs = partialSig;
     }
     return pSigs.map((p) => p.signature);
 }

package/build/psbt.d.ts

@@ -1,6 +1,6 @@
 import { Psbt as PsbtBase } from 'bip174';
 import { KeyValue, PartialSig, PsbtGlobal, PsbtGlobalUpdate, PsbtInput, PsbtInputUpdate, PsbtOutput, PsbtOutputUpdate } from 'bip174/src/lib/interfaces.js';
-import { BIP32Interface } from 'bip32';
+import { BIP32Interface } from '@btc-vision/bip32';
 import { ECPairInterface } from 'ecpair';
 import { Network } from './networks.js';
 import { Transaction } from './transaction.js';

package/build/psbt.js

@@ -1,5 +1,6 @@
 import { Psbt as PsbtBase } from 'bip174';
 import * as varuint from 'bip174/src/lib/converter/varint.js';
+const varuintDecode = varuint.decode;
 import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.js';
 import { fromOutputScript, isUnknownSegwitVersion, toOutputScript } from './address.js';
 import { cloneBuffer, reverseBuffer } from './bufferutils.js';
@@ -94,7 +95,8 @@ export class Psbt {
         return this;
     }
     clone() {
-        return Psbt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
+        const clonedOpts = JSON.parse(JSON.stringify(this.opts));
+        return Psbt.fromBuffer(this.data.toBuffer(), clonedOpts);
     }
     setMaximumFeeRate(satoshiPerByte) {
         check32Bit(satoshiPerByte);
@@ -164,16 +166,18 @@ export class Psbt {
         return this;
     }
     addOutput(outputData) {
+        const hasAddress = 'address' in outputData;
+        const hasScript = 'script' in outputData;
         if (arguments.length > 1 ||
             !outputData ||
             outputData.value === undefined ||
-            (outputData.address === undefined && outputData.script === undefined)) {
+            (!hasAddress && !hasScript)) {
             throw new Error(`Invalid arguments for Psbt.addOutput. ` +
                 `Requires single object with at least [script or address] and [value]`);
         }
         checkInputsForPartialSig(this.data.inputs, 'addOutput');
-        const { address } = outputData;
-        if (typeof address === 'string') {
+        if (hasAddress) {
+            const { address } = outputData;
             const { network } = this.opts;
             const script = toOutputScript(address, network);
             outputData = Object.assign({}, outputData, { script });
@@ -255,7 +259,7 @@ export class Psbt {
     validateSignaturesOfAllInputs(validator) {
         checkForInput(this.data.inputs, 0);
         const results = range(this.data.inputs.length).map((idx) => this.validateSignaturesOfInput(idx, validator));
-        return results.reduce((final, res) => res === true && final, true);
+        return results.reduce((final, res) => res && final, true);
     }
     validateSignaturesOfInput(inputIndex, validator, pubkey) {
         const input = this.data.inputs[inputIndex];
@@ -277,7 +281,7 @@ export class Psbt {
                 results.push(false);
             }
         }
-        if (results.every((v) => v === false)) {
+        if (results.every((v) => !v)) {
             throw new Error('No inputs were signed');
         }
         return this;
@@ -297,7 +301,7 @@ export class Psbt {
                 }));
             }
             return Promise.all(promises).then(() => {
-                if (results.every((v) => v === false)) {
+                if (results.every((v) => !v)) {
                     return reject(new Error('No inputs were signed'));
                 }
                 resolve();
@@ -339,7 +343,7 @@ export class Psbt {
                 results.push(false);
             }
         }
-        if (results.every((v) => v === false)) {
+        if (results.every((v) => !v)) {
             throw new Error('No inputs were signed');
         }
         return this;
@@ -358,7 +362,7 @@ export class Psbt {
                 }));
             }
             return Promise.all(promises).then(() => {
-                if (results.every((v) => v === false)) {
+                if (results.every((v) => !v)) {
                     return reject(new Error('No inputs were signed'));
                 }
                 resolve();
@@ -456,9 +460,12 @@ export class Psbt {
     checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes) {
         if (typeof keyPair.signSchnorr !== 'function')
             throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
-        const hashesForSig = getTaprootHashesForSig(inputIndex, input, this.data.inputs, keyPair.publicKey, this.__CACHE, tapLeafHashToSign, allowedSighashTypes);
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+        const hashesForSig = getTaprootHashesForSig(inputIndex, input, this.data.inputs, pubkey, this.__CACHE, tapLeafHashToSign, allowedSighashTypes);
         if (!hashesForSig || !hashesForSig.length)
-            throw new Error(`Can not sign for input #${inputIndex} with the key ${keyPair.publicKey.toString('hex')}`);
+            throw new Error(`Can not sign for input #${inputIndex} with the key ${pubkey.toString('hex')}`);
         return hashesForSig;
     }
     _finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts, canRunChecks = true) {
@@ -484,6 +491,8 @@ export class Psbt {
                 output: input.witnessUtxo.script,
                 signature: input.tapKeySig,
             });
+            if (!payment.witness)
+                throw new Error('Cannot finalize taproot key spend');
             const finalScriptWitness = witnessStackToScriptWitness(payment.witness);
             this.data.updateInput(inputIndex, { finalScriptWitness });
         }
@@ -510,7 +519,7 @@ export class Psbt {
         let sighashCache;
         for (const pSig of mySigs) {
             const sig = bscript.signature.decode(pSig.signature);
-            const { hash, script } = sighashCache !== sig.hashType
+            const { hash, script } = sighashCache !== sig.hashType || !hashCache || !scriptCache
                 ? getHashForSig(inputIndex, Object.assign({}, input, {
                     sighashType: sig.hashType,
                 }), this.__CACHE, true)
@@ -521,7 +530,7 @@ export class Psbt {
             checkScriptForPubkey(pSig.pubkey, script, 'verify');
             results.push(validator(pSig.pubkey, hash, sig.signature));
         }
-        return results.every((res) => res === true);
+        return results.every((res) => res);
     }
     validateSignaturesOfTaprootInput(inputIndex, validator, pubkey) {
         const input = this.data.inputs[inputIndex];
@@ -559,26 +568,35 @@ export class Psbt {
         return validationResultCount > 0;
     }
     _signInput(inputIndex, keyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
-        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, keyPair.publicKey, this.__CACHE, sighashTypes);
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, pubkey, this.__CACHE, sighashTypes);
+        const sig = keyPair.sign(hash);
         const partialSig = [
             {
-                pubkey: keyPair.publicKey,
-                signature: bscript.signature.encode(keyPair.sign(hash), sighashType),
+                pubkey,
+                signature: bscript.signature.encode(Buffer.isBuffer(sig) ? sig : Buffer.from(sig), sighashType),
             },
         ];
         this.data.updateInput(inputIndex, { partialSig });
         return this;
     }
     _signTaprootInput(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes = [Transaction.SIGHASH_DEFAULT]) {
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
         const hashesForSig = this.checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHashToSign, allowedSighashTypes);
+        const signSchnorr = keyPair.signSchnorr.bind(keyPair);
+        const toBuffer = (data) => Buffer.isBuffer(data) ? data : Buffer.from(data);
         const tapKeySig = hashesForSig
             .filter((h) => !h.leafHash)
-            .map((h) => serializeTaprootSignature(keyPair.signSchnorr(h.hash), input.sighashType))[0];
+            .map((h) => serializeTaprootSignature(toBuffer(signSchnorr(h.hash)), input.sighashType))[0];
         const tapScriptSig = hashesForSig
             .filter((h) => !!h.leafHash)
             .map((h) => ({
-            pubkey: toXOnly(keyPair.publicKey),
-            signature: serializeTaprootSignature(keyPair.signSchnorr(h.hash), input.sighashType),
+            pubkey: toXOnly(pubkey),
+            signature: serializeTaprootSignature(toBuffer(signSchnorr(h.hash)), input.sighashType),
             leafHash: h.leafHash,
         }));
         if (tapKeySig) {
@@ -590,25 +608,34 @@ export class Psbt {
         return this;
     }
     _signInputAsync(inputIndex, keyPair, sighashTypes = [Transaction.SIGHASH_ALL]) {
-        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, keyPair.publicKey, this.__CACHE, sighashTypes);
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
+        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, pubkey, this.__CACHE, sighashTypes);
         return Promise.resolve(keyPair.sign(hash)).then((signature) => {
+            const sig = Buffer.isBuffer(signature) ? signature : Buffer.from(signature);
             const partialSig = [
                 {
-                    pubkey: keyPair.publicKey,
-                    signature: bscript.signature.encode(signature, sighashType),
+                    pubkey,
+                    signature: bscript.signature.encode(sig, sighashType),
                 },
             ];
             this.data.updateInput(inputIndex, { partialSig });
         });
     }
     async _signTaprootInputAsync(inputIndex, input, keyPair, tapLeafHash, sighashTypes = [Transaction.SIGHASH_DEFAULT]) {
+        const pubkey = Buffer.isBuffer(keyPair.publicKey)
+            ? keyPair.publicKey
+            : Buffer.from(keyPair.publicKey);
         const hashesForSig = this.checkTaprootHashesForSig(inputIndex, input, keyPair, tapLeafHash, sighashTypes);
+        const signSchnorr = keyPair.signSchnorr.bind(keyPair);
+        const toBuffer = (data) => Buffer.isBuffer(data) ? data : Buffer.from(data);
         const signaturePromises = [];
         const tapKeyHash = hashesForSig.filter((h) => !h.leafHash)[0];
         if (tapKeyHash) {
-            const tapKeySigPromise = Promise.resolve(keyPair.signSchnorr(tapKeyHash.hash)).then((sig) => {
+            const tapKeySigPromise = Promise.resolve(signSchnorr(tapKeyHash.hash)).then((sig) => {
                 return {
-                    tapKeySig: serializeTaprootSignature(sig, input.sighashType),
+                    tapKeySig: serializeTaprootSignature(toBuffer(sig), input.sighashType),
                 };
             });
             signaturePromises.push(tapKeySigPromise);
@@ -616,11 +643,11 @@ export class Psbt {
         const tapScriptHashes = hashesForSig.filter((h) => !!h.leafHash);
         if (tapScriptHashes.length) {
             const tapScriptSigPromises = tapScriptHashes.map(async (tsh) => {
-                const signature = await keyPair.signSchnorr(tsh.hash);
+                const signature = await signSchnorr(tsh.hash);
                 const tapScriptSig = [
                     {
-                        pubkey: toXOnly(keyPair.publicKey),
-                        signature: serializeTaprootSignature(signature, input.sighashType),
+                        pubkey: toXOnly(pubkey),
+                        signature: serializeTaprootSignature(toBuffer(signature), input.sighashType),
                         leafHash: tsh.leafHash,
                     },
                 ];
@@ -681,11 +708,12 @@ function canFinalize(input, script, scriptType) {
         case 'pubkeyhash':
         case 'witnesspubkeyhash':
             return hasSigs(1, input.partialSig);
-        case 'multisig':
+        case 'multisig': {
             const p2ms = payments.p2ms({
                 output: script,
             });
             return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);
+        }
         case 'nonstandard':
             return true;
         default:
@@ -693,7 +721,7 @@ function canFinalize(input, script, scriptType) {
     }
 }
 function checkCache(cache) {
-    if (cache.__UNSAFE_SIGN_NONSEGWIT !== false) {
+    if (cache.__UNSAFE_SIGN_NONSEGWIT) {
         throw new Error('Not BIP174 compliant, can not export');
     }
 }
@@ -721,9 +749,14 @@ function isFinalized(input) {
 }
 function bip32DerivationIsMine(root) {
     return (d) => {
-        if (!d.masterFingerprint.equals(root.fingerprint))
+        const fingerprint = Buffer.isBuffer(root.fingerprint)
+            ? root.fingerprint
+            : Buffer.from(root.fingerprint);
+        if (!d.masterFingerprint.equals(fingerprint))
             return false;
-        if (!root.derivePath(d.path).publicKey.equals(d.pubkey))
+        const derivedPubkey = root.derivePath(d.path).publicKey;
+        const pubkey = Buffer.isBuffer(derivedPubkey) ? derivedPubkey : Buffer.from(derivedPubkey);
+        if (!pubkey.equals(d.pubkey))
             return false;
         return true;
     };
@@ -785,7 +818,7 @@ function checkTxForDupeIns(tx, cache) {
     });
 }
 function checkTxInputCache(cache, input) {
-    const key = reverseBuffer(Buffer.from(input.hash)).toString('hex') + ':' + input.index;
+    const key = `${reverseBuffer(Buffer.from(input.hash)).toString('hex')}:${input.index}`;
     if (cache.__TX_IN_CACHE[key])
         throw new Error('Duplicate input detected.');
     cache.__TX_IN_CACHE[key] = 1;
@@ -819,10 +852,10 @@ function getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
         tx = c.__TX.clone();
     }
     inputFinalizeGetAmts(inputs, tx, c, mustFinalize, disableOutputChecks);
-    if (key === '__FEE_RATE')
-        return c.__FEE_RATE;
-    else if (key === '__FEE')
-        return c.__FEE;
+    const value = key === '__FEE_RATE' ? c.__FEE_RATE : c.__FEE;
+    if (value === undefined)
+        throw new Error(`Failed to calculate ${name}`);
+    return value;
 }
 export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true, solution) {
     const scriptType = classifyScript(script);
@@ -907,15 +940,15 @@ function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
     }
     else if (isP2WPKH(meaningfulScript)) {
         const signingScript = payments.p2pkh({
-            hash: meaningfulScript.slice(2),
+            hash: meaningfulScript.subarray(2),
         }).output;
         hash = unsignedTx.hashForWitnessV0(inputIndex, signingScript, prevout.value, sighashType);
     }
     else {
-        if (input.nonWitnessUtxo === undefined && cache.__UNSAFE_SIGN_NONSEGWIT === false)
+        if (input.nonWitnessUtxo === undefined && !cache.__UNSAFE_SIGN_NONSEGWIT)
             throw new Error(`Input #${inputIndex} has witnessUtxo but non-segwit script: ` +
-                `${meaningfulScript.toString('hex')}`);
-        if (!forValidate && cache.__UNSAFE_SIGN_NONSEGWIT !== false)
+                meaningfulScript.toString('hex'));
+        if (!forValidate && cache.__UNSAFE_SIGN_NONSEGWIT)
             console.warn('Warning: Signing non-segwit inputs without the full parent transaction ' +
                 'means there is a chance that a miner could feed you incorrect information ' +
                 "to trick you into paying large fees. This behavior is the same as Psbt's predecessor " +
@@ -1109,11 +1142,11 @@ function scriptWitnessToWitnessStack(buffer) {
     let offset = 0;
     function readSlice(n) {
         offset += n;
-        return buffer.slice(offset - n, offset);
+        return buffer.subarray(offset - n, offset);
     }
     function readVarInt() {
-        const vi = varuint.decode(buffer, offset);
-        offset += varuint.decode.bytes;
+        const vi = varuintDecode(buffer, offset);
+        offset += varuintDecode.bytes;
         return vi;
     }
     function readVarSlice() {
@@ -1265,11 +1298,11 @@ function redeemFromFinalWitnessScript(finalScript) {
 function compressPubkey(pubkey) {
     if (pubkey.length === 65) {
         const parity = pubkey[64] & 1;
-        const newKey = pubkey.slice(0, 33);
+        const newKey = Buffer.from(pubkey.subarray(0, 33));
         newKey[0] = 2 | parity;
         return newKey;
     }
-    return pubkey.slice();
+    return Buffer.from(pubkey);
 }
 function isPubkeyLike(buf) {
     return buf.length === 33 && bscript.isCanonicalPubKey(buf);

package/build/script.js

@@ -92,7 +92,7 @@ export function decompile(buffer) {
             i += d.size;
             if (i + d.number > buffer.length)
                 return null;
-            const data = buffer.slice(i, i + d.number);
+            const data = buffer.subarray(i, i + d.number);
             i += d.number;
             const op = asMinimalOP(data);
             if (op !== undefined) {
@@ -161,7 +161,7 @@ export function isCanonicalScriptSignature(buffer) {
         return false;
     if (!isDefinedHashType(buffer[buffer.length - 1]))
         return false;
-    return bip66.check(buffer.slice(0, -1));
+    return bip66.check(buffer.subarray(0, -1));
 }
 export const number = scriptNumber;
 export const signature = scriptSignature;

package/build/script_signature.js

@@ -9,14 +9,14 @@ function toDER(x) {
         ++i;
     if (i === x.length)
         return ZERO;
-    x = x.slice(i);
+    x = x.subarray(i);
     if (x[0] & 0x80)
         return Buffer.concat([ZERO, x], 1 + x.length);
     return x;
 }
 function fromDER(x) {
     if (x[0] === 0x00)
-        x = x.slice(1);
+        x = x.subarray(1);
     const buffer = Buffer.alloc(32, 0);
     const bstart = Math.max(0, 32 - x.length);
     x.copy(buffer, bstart);
@@ -25,9 +25,9 @@ function fromDER(x) {
 export function decode(buffer) {
     const hashType = buffer.readUInt8(buffer.length - 1);
     if (!isDefinedHashType(hashType)) {
-        throw new Error('Invalid hashType ' + hashType);
+        throw new Error(`Invalid hashType ${hashType}`);
     }
-    const decoded = bip66.decode(buffer.slice(0, -1));
+    const decoded = bip66.decode(buffer.subarray(0, -1));
     const r = fromDER(decoded.r);
     const s = fromDER(decoded.s);
     const signature = Buffer.concat([r, s], 64);
@@ -39,11 +39,11 @@ export function encode(signature, hashType) {
         hashType: types.UInt8,
     }, { signature, hashType });
     if (!isDefinedHashType(hashType)) {
-        throw new Error('Invalid hashType ' + hashType);
+        throw new Error(`Invalid hashType ${hashType}`);
     }
     const hashTypeBuffer = Buffer.allocUnsafe(1);
     hashTypeBuffer.writeUInt8(hashType, 0);
-    const r = toDER(signature.slice(0, 32));
-    const s = toDER(signature.slice(32, 64));
+    const r = toDER(signature.subarray(0, 32));
+    const s = toDER(signature.subarray(32, 64));
     return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);
 }

package/build/transaction.js

@@ -25,7 +25,7 @@ const BLANK_OUTPUT = {
     valueBuffer: VALUE_UINT64_MAX,
 };
 function isOutput(out) {
-    return out.value !== undefined;
+    return 'value' in out;
 }
 export class Transaction {
     constructor() {
@@ -98,7 +98,7 @@ export class Transaction {
         return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash);
     }
     addInput(hash, index, sequence, scriptSig) {
-        typeforce(types.tuple(types.Hash256bit, types.UInt32, types.maybe(types.UInt32), types.maybe(types.Buffer)), arguments);
+        typeforce(types.tuple(types.Hash256bit, types.UInt32, types.maybe(types.UInt32), types.maybe(types.Buffer)), [hash, index, sequence, scriptSig]);
         if (types.Null(sequence)) {
             sequence = Transaction.DEFAULT_SEQUENCE;
         }
@@ -111,7 +111,7 @@ export class Transaction {
         }) - 1);
     }
     addOutput(scriptPubKey, value) {
-        typeforce(types.tuple(types.Buffer, types.Satoshi), arguments);
+        typeforce(types.tuple(types.Buffer, types.Satoshi), [scriptPubKey, value]);
         return (this.outs.push({
             script: scriptPubKey,
             value,
@@ -169,10 +169,17 @@ export class Transaction {
         return newTx;
     }
     hashForSignature(inIndex, prevOutScript, hashType) {
-        typeforce(types.tuple(types.UInt32, types.Buffer, types.Number), arguments);
+        typeforce(types.tuple(types.UInt32, types.Buffer, types.Number), [
+            inIndex,
+            prevOutScript,
+            hashType,
+        ]);
         if (inIndex >= this.ins.length)
             return ONE;
-        const ourScript = bscript.compile(bscript.decompile(prevOutScript).filter((x) => {
+        const decompiled = bscript.decompile(prevOutScript);
+        if (!decompiled)
+            throw new Error('Could not decompile prevOutScript');
+        const ourScript = bscript.compile(decompiled.filter((x) => {
             return x !== opcodes.OP_CODESEPARATOR;
         }));
         const txTmp = this.clone();
@@ -213,7 +220,7 @@ export class Transaction {
         return bcrypto.hash256(buffer);
     }
     hashForWitnessV1(inIndex, prevOutScripts, values, hashType, leafHash, annex) {
-        typeforce(types.tuple(types.UInt32, typeforce.arrayOf(types.Buffer), typeforce.arrayOf(types.Satoshi), types.UInt32), arguments);
+        typeforce(types.tuple(types.UInt32, typeforce.arrayOf(types.Buffer), typeforce.arrayOf(types.Satoshi), types.UInt32), [inIndex, prevOutScripts, values, hashType]);
         if (values.length !== this.ins.length || prevOutScripts.length !== this.ins.length) {
             throw new Error('Must supply prevout script and value for all inputs');
         }
@@ -311,7 +318,12 @@ export class Transaction {
         return bcrypto.taggedHash('TapSighash', Buffer.concat([Buffer.from([0x00]), sigMsgWriter.end()]));
     }
     hashForWitnessV0(inIndex, prevOutScript, value, hashType) {
-        typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), arguments);
+        typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), [
+            inIndex,
+            prevOutScript,
+            value,
+            hashType,
+        ]);
         let tbuffer = Buffer.from([]);
         let bufferWriter;
         let hashOutputs = ZERO;
@@ -388,11 +400,11 @@ export class Transaction {
         return this.toBuffer(undefined, undefined).toString('hex');
     }
     setInputScript(index, scriptSig) {
-        typeforce(types.tuple(types.Number, types.Buffer), arguments);
+        typeforce(types.tuple(types.Number, types.Buffer), [index, scriptSig]);
         this.ins[index].script = scriptSig;
     }
     setWitness(index, witness) {
-        typeforce(types.tuple(types.Number, [types.Buffer]), arguments);
+        typeforce(types.tuple(types.Number, [types.Buffer]), [index, witness]);
         this.ins[index].witness = witness;
     }
     __toBuffer(buffer, initialOffset, _ALLOW_WITNESS = false) {
@@ -429,7 +441,7 @@ export class Transaction {
         }
         bufferWriter.writeUInt32(this.locktime);
         if (initialOffset !== undefined)
-            return buffer.slice(initialOffset, bufferWriter.offset);
+            return buffer.subarray(initialOffset, bufferWriter.offset);
         return buffer;
     }
 }