@opcat-labs/scrypt-ts-opcat 1.0.0

package/dist/cjs/psbt/psbt.cjs

@@ -0,0 +1,973 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFinalized = exports.Psbt = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const bip174_1 = require("@opcat-labs/bip174");
+const bip174_2 = require("@opcat-labs/bip174");
+const opcat_1 = require("@opcat-labs/opcat");
+const signatureutils = __importStar(require('./signatureutils.cjs'));
+const bufferutils_js_1 = require('./bufferutils.cjs');
+const psbtutils_js_1 = require('./psbtutils.cjs');
+const tools = __importStar(require("uint8array-tools"));
+/**
+ * These are the default arguments for a Psbt instance.
+ */
+const DEFAULT_OPTS = {
+    /**
+     * A bitcoinjs Network object. This is only used if you pass an `address`
+     * parameter to addOutput. Otherwise it is not needed and can be left default.
+     */
+    network: opcat_1.Networks.testnet,
+    /**
+     * When extractTransaction is called, the fee rate is checked.
+     * THIS IS NOT TO BE RELIED ON.
+     * It is only here as a last ditch effort to prevent sending a 500 BTC fee etc.
+     */
+    maximumFeeRate: 5000, // satoshi per byte
+};
+/**
+ * Psbt class can parse and generate a PSBT binary based off of the BIP174.
+ * There are 6 roles that this class fulfills. (Explained in BIP174)
+ *
+ * Creator: This can be done with `new Psbt()`
+ *
+ * Updater: This can be done with `psbt.addInput(input)`, `psbt.addInputs(inputs)`,
+ *   `psbt.addOutput(output)`, `psbt.addOutputs(outputs)` when you are looking to
+ *   add new inputs and outputs to the PSBT, and `psbt.updateGlobal(itemObject)`,
+ *   `psbt.updateInput(itemObject)`, `psbt.updateOutput(itemObject)`
+ *   addInput requires hash: Buffer | string; and index: number; as attributes
+ *   and can also include any attributes that are used in updateInput method.
+ *   addOutput requires script: Buffer; and value: number; and likewise can include
+ *   data for updateOutput.
+ *   For a list of what attributes should be what types. Check the bip174 library.
+ *   Also, check the integration tests for some examples of usage.
+ *
+ * Signer: There are a few methods. signAllInputs and signAllInputsAsync, which will search all input
+ *   information for your pubkey or pubkeyhash, and only sign inputs where it finds
+ *   your info. Or you can explicitly sign a specific input with signInput and
+ *   signInputAsync. For the async methods you can create a SignerAsync object
+ *   and use something like a hardware wallet to sign with. (You must implement this)
+ *
+ * Combiner: psbts can be combined easily with `psbt.combine(psbt2, psbt3, psbt4 ...)`
+ *   the psbt calling combine will always have precedence when a conflict occurs.
+ *   Combine checks if the internal bitcoin transaction is the same, so be sure that
+ *   all sequences, version, locktime, etc. are the same before combining.
+ *
+ * Input Finalizer: This role is fairly important. Not only does it need to construct
+ *   the input scriptSigs and witnesses, but it SHOULD verify the signatures etc.
+ *   Before running `psbt.finalizeAllInputs()` please run `psbt.validateSignaturesOfAllInputs()`
+ *   Running any finalize method will delete any data in the input(s) that are no longer
+ *   needed due to the finalized scripts containing the information.
+ *
+ * Transaction Extractor: This role will perform some checks before returning a
+ *   Transaction object. Such as fee rate not being larger than maximumFeeRate etc.
+ */
+class Psbt {
+    static fromBase64(data, opts = {}) {
+        const buffer = tools.fromBase64(data);
+        return this.fromBuffer(buffer, opts);
+    }
+    static fromHex(data, opts = {}) {
+        const buffer = tools.fromHex(data);
+        return this.fromBuffer(buffer, opts);
+    }
+    static fromBuffer(buffer, opts = {}) {
+        const psbtBase = bip174_1.Psbt.fromBuffer(buffer, transactionFromBuffer);
+        const psbt = new Psbt(opts, psbtBase);
+        checkTxForDupeIns(psbt.__CACHE.__TX, psbt.__CACHE);
+        return psbt;
+    }
+    constructor(opts = {}, data = new bip174_1.Psbt(new PsbtTransaction())) {
+        this.data = data;
+        // set defaults
+        this.opts = Object.assign({}, DEFAULT_OPTS, opts);
+        this.__CACHE = {
+            __TX_IN_CACHE: {},
+            __TX: this.data.globalMap.unsignedTx.tx,
+            // Psbt's predecessor (TransactionBuilder - now removed) behavior
+            // was to not confirm input values  before signing.
+            // Even though we highly encourage people to get
+            // the full parent transaction to verify values, the ability to
+            // sign non-segwit inputs without the full transaction was often
+            // requested. So the only way to activate is to use @ts-ignore.
+            // We will disable exporting the Psbt when unsafe sign is active.
+            // because it is not BIP174 compliant.
+            __UNSAFE_SIGN_NONSEGWIT: false,
+        };
+        //if (this.data.inputs.length === 0) this.setVersion(2);
+        for (let i = 0; i < this.__CACHE.__TX.inputs.length; i++) {
+            const input = this.__CACHE.__TX.inputs[i];
+            if (!this.data.inputs[i] || !this.data.inputs[i].opcatUtxo) {
+                throw new Error('invalid pbst input');
+            }
+            input.output = new opcat_1.Transaction.Output({
+                satoshis: Number(this.data.inputs[i].opcatUtxo.value),
+                script: new opcat_1.Script(Buffer.from(this.data.inputs[i].opcatUtxo.script)),
+                data: Buffer.from(this.data.inputs[i].opcatUtxo.data),
+            });
+        }
+        // Make data hidden when enumerating
+        const dpew = (obj, attr, enumerable, writable) => Object.defineProperty(obj, attr, {
+            enumerable,
+            writable,
+        });
+        dpew(this, '__CACHE', false, true);
+        dpew(this, 'opts', false, true);
+    }
+    get inputCount() {
+        return this.data.inputs.length;
+    }
+    get version() {
+        return this.__CACHE.__TX.version;
+    }
+    set version(version) {
+        this.setVersion(version);
+    }
+    get locktime() {
+        return this.__CACHE.__TX.version;
+    }
+    set locktime(locktime) {
+        this.setLocktime(locktime);
+    }
+    get txInputs() {
+        return this.__CACHE.__TX.inputs.map(input => ({
+            hash: Buffer.from(input.prevTxId).reverse(),
+            index: input.outputIndex,
+            sequence: input.sequenceNumber,
+        }));
+    }
+    get txOutputs() {
+        return this.__CACHE.__TX.outputs.map(output => {
+            let address;
+            try {
+                address = opcat_1.Address.fromHex(output.script.toHex(), this.opts.network);
+                // eslint-disable-next-line no-empty
+            }
+            catch (_) { }
+            return {
+                script: (0, bufferutils_js_1.cloneBuffer)(output.script.toBuffer()),
+                value: BigInt(output.satoshis),
+                data: output.data || new Uint8Array(),
+                address,
+            };
+        });
+    }
+    combine(...those) {
+        this.data.combine(...those.map(o => o.data));
+        return this;
+    }
+    clone() {
+        // TODO: more efficient cloning
+        const res = Psbt.fromBuffer(this.data.toBuffer());
+        res.opts = JSON.parse(JSON.stringify(this.opts));
+        return res;
+    }
+    setMaximumFeeRate(satoshiPerByte) {
+        check32Bit(satoshiPerByte); // 42.9 BTC per byte IS excessive... so throw
+        this.opts.maximumFeeRate = satoshiPerByte;
+    }
+    setVersion(version) {
+        check32Bit(version);
+        checkInputsForPartialSig(this.data.inputs, 'setVersion');
+        const c = this.__CACHE;
+        c.__TX.version = version;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    setLocktime(locktime) {
+        check32Bit(locktime);
+        checkInputsForPartialSig(this.data.inputs, 'setLocktime');
+        const c = this.__CACHE;
+        c.__TX.nLockTime = locktime;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    setInputSequence(inputIndex, sequence) {
+        check32Bit(sequence);
+        checkInputsForPartialSig(this.data.inputs, 'setInputSequence');
+        const c = this.__CACHE;
+        if (c.__TX.inputs.length <= inputIndex) {
+            throw new Error('Input index too high');
+        }
+        c.__TX.inputs[inputIndex].sequenceNumber = sequence;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    addInputs(inputDatas) {
+        inputDatas.forEach(inputData => this.addInput(inputData));
+        return this;
+    }
+    addInput(inputData) {
+        if (arguments.length > 1 ||
+            !inputData ||
+            inputData.hash === undefined ||
+            inputData.index === undefined ||
+            inputData.opcatUtxo === undefined) {
+            throw new Error(`Invalid arguments for Psbt.addInput. ` +
+                `Requires single object with at least [hash] and [index] and [opcatUtxo]`);
+        }
+        checkInputsForPartialSig(this.data.inputs, 'addInput');
+        const c = this.__CACHE;
+        this.data.addInput(inputData);
+        const txIn = c.__TX.inputs[c.__TX.inputs.length - 1];
+        checkTxInputCache(c, txIn);
+        c.__FEE = undefined;
+        c.__FEE_RATE = undefined;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    addOutputs(outputDatas) {
+        outputDatas.forEach(outputData => this.addOutput(outputData));
+        return this;
+    }
+    addOutput(outputData) {
+        if (arguments.length > 1 ||
+            !outputData ||
+            outputData.value === undefined ||
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (outputData.address === undefined &&
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                outputData.script === undefined &&
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                outputData.data === undefined)) {
+            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') {
+            const script = opcat_1.Script.fromAddress(address);
+            outputData = Object.assign({}, outputData, { script });
+        }
+        const c = this.__CACHE;
+        this.data.addOutput(outputData);
+        c.__FEE = undefined;
+        c.__FEE_RATE = undefined;
+        c.__EXTRACTED_TX = undefined;
+        return this;
+    }
+    extractTransaction(disableFeeCheck) {
+        if (!this.data.inputs.every(isFinalized))
+            throw new Error('Not finalized');
+        const c = this.__CACHE;
+        if (!disableFeeCheck) {
+            checkFees(this, c, this.opts);
+        }
+        if (c.__EXTRACTED_TX)
+            return c.__EXTRACTED_TX;
+        const tx = c.__TX.clone();
+        inputFinalizeGetAmts(this.data.inputs, tx, c, true);
+        return tx;
+    }
+    getFeeRate() {
+        return getTxCacheValue('__FEE_RATE', 'fee rate', this.data.inputs, this.__CACHE);
+    }
+    getFee() {
+        return getTxCacheValue('__FEE', 'fee', this.data.inputs, this.__CACHE);
+    }
+    finalizeAllInputs() {
+        (0, bip174_2.checkForInput)(this.data.inputs, 0); // making sure we have at least one
+        range(this.data.inputs.length).forEach(idx => this.finalizeInput(idx));
+        return this;
+    }
+    finalizeInput(inputIndex, finalScriptsFunc) {
+        const input = (0, bip174_2.checkForInput)(this.data.inputs, inputIndex);
+        return this._finalizeInput(inputIndex, input, finalScriptsFunc);
+    }
+    _finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts) {
+        const { script } = getScriptFromInput(inputIndex, input, this.__CACHE);
+        if (!script)
+            throw new Error(`No script found for input #${inputIndex}`);
+        checkPartialSigSighashes(input);
+        const { finalScriptSig } = finalScriptsFunc(inputIndex, input, script);
+        if (finalScriptSig)
+            this.data.updateInput(inputIndex, { finalScriptSig });
+        else
+            throw new Error(`Unknown error finalizing input #${inputIndex}`);
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+    getInputType(inputIndex) {
+        const input = (0, bip174_2.checkForInput)(this.data.inputs, inputIndex);
+        const script = getScriptFromUtxo(inputIndex, input, this.__CACHE);
+        const result = getMeaningfulScript(script);
+        const type = result.type === 'raw' ? '' : result.type + '-';
+        const mainType = classifyScript(result.meaningfulScript);
+        return (type + mainType);
+    }
+    inputHasPubkey(inputIndex, pubkey) {
+        const input = (0, bip174_2.checkForInput)(this.data.inputs, inputIndex);
+        return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
+    }
+    inputHasHDKey(inputIndex, root) {
+        const input = (0, bip174_2.checkForInput)(this.data.inputs, inputIndex);
+        const derivationIsMine = bip32DerivationIsMine(root);
+        return (!!input.bip32Derivation && input.bip32Derivation.some(derivationIsMine));
+    }
+    outputHasPubkey(outputIndex, pubkey) {
+        return pubkeyInOutput(pubkey, outputIndex, this.__CACHE);
+    }
+    outputHasHDKey(outputIndex, root) {
+        const output = (0, bip174_2.checkForOutput)(this.data.outputs, outputIndex);
+        const derivationIsMine = bip32DerivationIsMine(root);
+        return (!!output.bip32Derivation && output.bip32Derivation.some(derivationIsMine));
+    }
+    validateSignaturesOfAllInputs(validator) {
+        (0, bip174_2.checkForInput)(this.data.inputs, 0); // making sure we have at least one
+        const results = range(this.data.inputs.length).map(idx => this.validateSignaturesOfInput(idx, validator));
+        return results.reduce((final, res) => res === true && final, true);
+    }
+    validateSignaturesOfInput(inputIndex, validator, pubkey) {
+        return this._validateSignaturesOfInput(inputIndex, validator, pubkey);
+    }
+    _validateSignaturesOfInput(inputIndex, validator, pubkey) {
+        const input = this.data.inputs[inputIndex];
+        const partialSig = (input || {}).partialSig;
+        if (!input || !partialSig || partialSig.length < 1)
+            throw new Error('No signatures to validate');
+        if (typeof validator !== 'function')
+            throw new Error('Need validator function to validate signatures');
+        const mySigs = pubkey
+            ? partialSig.filter(sig => tools.compare(sig.pubkey, pubkey) === 0)
+            : partialSig;
+        if (mySigs.length < 1)
+            throw new Error('No signatures for this pubkey');
+        const results = [];
+        let hashCache;
+        let scriptCache;
+        let sighashCache;
+        for (const pSig of mySigs) {
+            const sig = signatureutils.decode(pSig.signature);
+            const { hash, script } = sighashCache !== sig.hashType
+                ? getHashForSig(inputIndex, Object.assign({}, input, { sighashType: sig.hashType }), this.__CACHE)
+                : { hash: hashCache, script: scriptCache };
+            sighashCache = sig.hashType;
+            hashCache = hash;
+            scriptCache = script;
+            checkScriptForPubkey(pSig.pubkey, script, 'verify');
+            results.push(validator(pSig.pubkey, hash, sig.signature));
+        }
+        return results.every(res => res === true);
+    }
+    signAllInputsHD(hdKeyPair, sighashTypes = [opcat_1.crypto.Signature.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const results = [];
+        for (const i of range(this.data.inputs.length)) {
+            try {
+                this.signInputHD(i, hdKeyPair, sighashTypes);
+                results.push(true);
+            }
+            catch (_) {
+                results.push(false);
+            }
+        }
+        if (results.every(v => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return this;
+    }
+    signAllInputsHDAsync(hdKeyPair, sighashTypes = [opcat_1.crypto.Signature.SIGHASH_ALL]) {
+        return new Promise((resolve, reject) => {
+            if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+                return reject(new Error('Need HDSigner to sign input'));
+            }
+            const results = [];
+            const promises = [];
+            for (const i of range(this.data.inputs.length)) {
+                promises.push(this.signInputHDAsync(i, hdKeyPair, sighashTypes).then(() => {
+                    results.push(true);
+                }, () => {
+                    results.push(false);
+                }));
+            }
+            return Promise.all(promises).then(() => {
+                if (results.every(v => v === false)) {
+                    return reject(new Error('No inputs were signed'));
+                }
+                resolve();
+            });
+        });
+    }
+    signInputHD(inputIndex, hdKeyPair, sighashTypes = [opcat_1.crypto.Signature.SIGHASH_ALL]) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+        signers.forEach(signer => this.signInput(inputIndex, signer, sighashTypes));
+        return this;
+    }
+    signInputHDAsync(inputIndex, hdKeyPair, sighashTypes = [opcat_1.crypto.Signature.SIGHASH_ALL]) {
+        return new Promise((resolve, reject) => {
+            if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+                return reject(new Error('Need HDSigner to sign input'));
+            }
+            const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+            const promises = signers.map(signer => this.signInputAsync(inputIndex, signer, sighashTypes));
+            return Promise.all(promises)
+                .then(() => {
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    signAllInputs(keyPair, sighashTypes) {
+        if (!keyPair || !keyPair.publicKey)
+            throw new Error('Need Signer to sign input');
+        // TODO: Add a pubkey/pubkeyhash cache to each input
+        // as input information is added, then eventually
+        // optimize this method.
+        const results = [];
+        for (const i of range(this.data.inputs.length)) {
+            try {
+                this.signInput(i, keyPair, sighashTypes);
+                results.push(true);
+            }
+            catch (_) {
+                results.push(false);
+            }
+        }
+        if (results.every(v => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return this;
+    }
+    signAllInputsAsync(keyPair, sighashTypes) {
+        return new Promise((resolve, reject) => {
+            if (!keyPair || !keyPair.publicKey)
+                return reject(new Error('Need Signer to sign input'));
+            // TODO: Add a pubkey/pubkeyhash cache to each input
+            // as input information is added, then eventually
+            // optimize this method.
+            const results = [];
+            const promises = [];
+            for (const [i] of this.data.inputs.entries()) {
+                promises.push(this.signInputAsync(i, keyPair, sighashTypes).then(() => {
+                    results.push(true);
+                }, () => {
+                    results.push(false);
+                }));
+            }
+            return Promise.all(promises).then(() => {
+                if (results.every(v => v === false)) {
+                    return reject(new Error('No inputs were signed'));
+                }
+                resolve();
+            });
+        });
+    }
+    signInput(inputIndex, keyPair, sighashTypes) {
+        if (!keyPair || !keyPair.publicKey)
+            throw new Error('Need Signer to sign input');
+        return this._signInput(inputIndex, keyPair, sighashTypes);
+    }
+    _signInput(inputIndex, keyPair, sighashTypes = [opcat_1.crypto.Signature.SIGHASH_ALL]) {
+        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, keyPair.publicKey, this.__CACHE, sighashTypes);
+        const partialSig = [
+            {
+                pubkey: keyPair.publicKey,
+                signature: signatureutils.encode(keyPair.sign(hash), sighashType),
+            },
+        ];
+        this.data.updateInput(inputIndex, { partialSig });
+        return this;
+    }
+    signInputAsync(inputIndex, keyPair, sighashTypes) {
+        return Promise.resolve().then(() => {
+            if (!keyPair || !keyPair.publicKey)
+                throw new Error('Need Signer to sign input');
+            return this._signInputAsync(inputIndex, keyPair, sighashTypes);
+        });
+    }
+    _signInputAsync(inputIndex, keyPair, sighashTypes = [opcat_1.crypto.Signature.SIGHASH_ALL]) {
+        const { hash, sighashType } = getHashAndSighashType(this.data.inputs, inputIndex, keyPair.publicKey, this.__CACHE, sighashTypes);
+        return Promise.resolve(keyPair.sign(hash)).then(signature => {
+            const partialSig = [
+                {
+                    pubkey: keyPair.publicKey,
+                    signature: signatureutils.encode(signature, sighashType),
+                },
+            ];
+            this.data.updateInput(inputIndex, { partialSig });
+        });
+    }
+    toBuffer() {
+        checkCache(this.__CACHE);
+        return this.data.toBuffer();
+    }
+    toHex() {
+        checkCache(this.__CACHE);
+        return this.data.toHex();
+    }
+    toBase64() {
+        checkCache(this.__CACHE);
+        return this.data.toBase64();
+    }
+    updateGlobal(updateData) {
+        this.data.updateGlobal(updateData);
+        return this;
+    }
+    updateInput(inputIndex, updateData) {
+        this.data.updateInput(inputIndex, updateData);
+        return this;
+    }
+    updateOutput(outputIndex, updateData) {
+        this.data.updateOutput(outputIndex, updateData);
+        return this;
+    }
+    addUnknownKeyValToGlobal(keyVal) {
+        this.data.addUnknownKeyValToGlobal(keyVal);
+        return this;
+    }
+    addUnknownKeyValToInput(inputIndex, keyVal) {
+        this.data.addUnknownKeyValToInput(inputIndex, keyVal);
+        return this;
+    }
+    addUnknownKeyValToOutput(outputIndex, keyVal) {
+        this.data.addUnknownKeyValToOutput(outputIndex, keyVal);
+        return this;
+    }
+    clearFinalizedInput(inputIndex) {
+        this.data.clearFinalizedInput(inputIndex);
+        return this;
+    }
+}
+exports.Psbt = Psbt;
+/**
+ * This function is needed to pass to the bip174 base class's fromBuffer.
+ * It takes the "transaction buffer" portion of the psbt buffer and returns a
+ * Transaction (From the bip174 library) interface.
+ */
+const transactionFromBuffer = (buffer) => new PsbtTransaction(buffer);
+/**
+ * This class implements the Transaction interface from bip174 library.
+ * It contains a bitcoinjs-lib Transaction object.
+ */
+class PsbtTransaction {
+    constructor(buffer = Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {
+        this.tx = opcat_1.Transaction.fromBuffer(Buffer.from(buffer));
+        checkTxEmpty(this.tx);
+        Object.defineProperty(this, 'tx', {
+            enumerable: false,
+            writable: true,
+        });
+    }
+    getInputOutputCounts() {
+        return {
+            inputCount: this.tx.inputs.length,
+            outputCount: this.tx.outputs.length,
+        };
+    }
+    addInput(input) {
+        if (input.hash === undefined ||
+            input.index === undefined ||
+            input.opcatUtxo === undefined ||
+            (!(input.hash instanceof Uint8Array) &&
+                typeof input.hash !== 'string') ||
+            typeof input.index !== 'number') {
+            throw new Error('Error adding input.');
+        }
+        const prevTxId = typeof input.hash === 'string'
+            ? input.hash
+            : (0, bufferutils_js_1.reverseBuffer)(tools.fromHex(input.hash));
+        this.tx.addInput(new opcat_1.Transaction.Input({
+            prevTxId: prevTxId,
+            outputIndex: input.index,
+            sequenceNumber: input.sequence
+        }), opcat_1.Script.fromBuffer(Buffer.from(input.opcatUtxo.script)), Number(input.opcatUtxo.value), Buffer.from(input.opcatUtxo.data));
+    }
+    addOutput(output) {
+        if (output.script === undefined ||
+            output.data === undefined ||
+            output.value === undefined ||
+            !(output.script instanceof Uint8Array) ||
+            !(output.data instanceof Uint8Array) ||
+            typeof output.value !== 'bigint') {
+            throw new Error('Error adding output.');
+        }
+        this.tx.addOutput(new opcat_1.Transaction.Output({
+            script: output.script,
+            satoshis: Number(output.value),
+            data: Buffer.from(output.data),
+        }));
+    }
+    toBuffer() {
+        return this.tx.toBuffer();
+    }
+}
+function canFinalize(input, script, scriptType) {
+    switch (scriptType) {
+        case 'pubkey':
+        case 'pubkeyhash':
+            return hasSigs(1, input.partialSig);
+        case 'multisig':
+            {
+                const ls = opcat_1.Script.fromBuffer(Buffer.from(script));
+                if (!ls.isMultisigOut()) {
+                    throw new Error('Script is not a multisig output');
+                }
+                const p2ms = ls.decodeMultisigOut();
+                return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);
+            }
+        default:
+            return false;
+    }
+}
+function checkCache(cache) {
+    if (cache.__UNSAFE_SIGN_NONSEGWIT !== false) {
+        throw new Error('Not BIP174 compliant, can not export');
+    }
+}
+function hasSigs(neededSigs, partialSig, pubkeys) {
+    if (!partialSig)
+        return false;
+    let sigs;
+    if (pubkeys) {
+        sigs = pubkeys
+            .map(pkey => {
+            const pubkey = compressPubkey(pkey);
+            return partialSig.find(pSig => tools.compare(pSig.pubkey, pubkey) === 0);
+        })
+            .filter(v => !!v);
+    }
+    else {
+        sigs = partialSig;
+    }
+    if (sigs.length > neededSigs)
+        throw new Error('Too many signatures');
+    return sigs.length === neededSigs;
+}
+function isFinalized(input) {
+    return !!input.finalScriptSig || !!input.finalScriptWitness;
+}
+exports.isFinalized = isFinalized;
+function bip32DerivationIsMine(root) {
+    return (d) => {
+        if (tools.compare(root.fingerprint, d.masterFingerprint))
+            return false;
+        if (tools.compare(root.derivePath(d.path).publicKey, d.pubkey))
+            return false;
+        return true;
+    };
+}
+function check32Bit(num) {
+    if (typeof num !== 'number' ||
+        num !== Math.floor(num) ||
+        num > 0xffffffff ||
+        num < 0) {
+        throw new Error('Invalid 32 bit integer');
+    }
+}
+function checkFees(psbt, cache, opts) {
+    const feeRate = cache.__FEE_RATE || psbt.getFeeRate();
+    const vsize = cache.__EXTRACTED_TX.getEstimateSize();
+    const satoshis = feeRate * vsize;
+    if (feeRate >= opts.maximumFeeRate) {
+        throw new Error(`Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
+            `fees, which is ${feeRate} satoshi per byte for a transaction ` +
+            `with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
+            `byte). Use setMaximumFeeRate method to raise your threshold, or ` +
+            `pass true to the first arg of extractTransaction.`);
+    }
+}
+function checkInputsForPartialSig(inputs, action) {
+    inputs.forEach(input => {
+        const throws = (0, psbtutils_js_1.checkInputForSig)(input, action);
+        if (throws)
+            throw new Error('Can not modify transaction, signatures exist.');
+    });
+}
+function checkPartialSigSighashes(input) {
+    if (!input.sighashType || !input.partialSig)
+        return;
+    const { partialSig, sighashType } = input;
+    partialSig.forEach((pSig) => {
+        const { hashType } = signatureutils.decode(pSig.signature);
+        if (sighashType !== hashType) {
+            throw new Error('Signature sighash does not match input sighash type');
+        }
+    });
+}
+function checkScriptForPubkey(pubkey, script, action) {
+    if (!(0, psbtutils_js_1.pubkeyInScript)(pubkey, script)) {
+        throw new Error(`Can not ${action} for this input with the key ${tools.toHex(pubkey)}`);
+    }
+}
+function checkTxEmpty(tx) {
+    const isEmpty = tx.inputs.every(input => input.script &&
+        input.script.length === 0);
+    if (!isEmpty) {
+        throw new Error('Format Error: Transaction ScriptSigs are not empty');
+    }
+}
+function checkTxForDupeIns(tx, cache) {
+    tx.inputs.forEach(input => {
+        checkTxInputCache(cache, input);
+    });
+}
+function checkTxInputCache(cache, input) {
+    const key = tools.toHex((0, bufferutils_js_1.reverseBuffer)(Uint8Array.from(input.prevTxId))) + ':' + input.outputIndex;
+    if (cache.__TX_IN_CACHE[key])
+        throw new Error('Duplicate input detected.');
+    cache.__TX_IN_CACHE[key] = 1;
+}
+function getTxCacheValue(key, name, inputs, c) {
+    if (!inputs.every(isFinalized))
+        throw new Error(`PSBT must be finalized to calculate ${name}`);
+    if (key === '__FEE_RATE' && c.__FEE_RATE)
+        return c.__FEE_RATE;
+    if (key === '__FEE' && c.__FEE)
+        return c.__FEE;
+    let tx;
+    let mustFinalize = true;
+    if (c.__EXTRACTED_TX) {
+        tx = c.__EXTRACTED_TX;
+        mustFinalize = false;
+    }
+    else {
+        tx = c.__TX.clone();
+    }
+    inputFinalizeGetAmts(inputs, tx, c, mustFinalize);
+    if (key === '__FEE_RATE')
+        return c.__FEE_RATE;
+    else if (key === '__FEE')
+        return c.__FEE;
+    return undefined;
+}
+function getFinalScripts(inputIndex, input, script) {
+    const scriptType = classifyScript(script);
+    if (!canFinalize(input, script, scriptType))
+        throw new Error(`Can not finalize input #${inputIndex}`);
+    return prepareFinalScripts(script, scriptType, input.partialSig);
+}
+function prepareFinalScripts(script, scriptType, partialSig) {
+    // Wow, the payments API is very handy
+    const us = getUnlockingScript(script, scriptType, partialSig);
+    const finalScriptSig = us.toBuffer();
+    return {
+        finalScriptSig,
+    };
+}
+function getHashAndSighashType(inputs, inputIndex, pubkey, cache, sighashTypes) {
+    const input = (0, bip174_2.checkForInput)(inputs, inputIndex);
+    const { hash, sighashType, script } = getHashForSig(inputIndex, input, cache, sighashTypes);
+    //checkScriptForPubkey(pubkey, script, 'sign');
+    return {
+        hash,
+        sighashType,
+    };
+}
+function getHashForSig(inputIndex, input, cache, sighashTypes) {
+    const unsignedTx = cache.__TX;
+    const sighashType = input.sighashType || opcat_1.crypto.Signature.SIGHASH_ALL;
+    checkSighashTypeAllowed(sighashType, sighashTypes);
+    const prevout = unsignedTx.inputs[inputIndex].output;
+    const { meaningfulScript } = getMeaningfulScript(prevout.script.toBuffer());
+    const hash = unsignedTx.hashForSignature(inputIndex, sighashType);
+    return {
+        script: meaningfulScript,
+        sighashType,
+        hash,
+    };
+}
+function checkSighashTypeAllowed(sighashType, sighashTypes) {
+    if (sighashTypes && sighashTypes.indexOf(sighashType) < 0) {
+        const str = sighashTypeToString(sighashType);
+        throw new Error(`Sighash type is not allowed. Retry the sign method passing the ` +
+            `sighashTypes array of whitelisted types. Sighash type: ${str}`);
+    }
+}
+function getUnlockingScript(script, scriptType, partialSig) {
+    let unlockingScript;
+    switch (scriptType) {
+        case 'multisig':
+            {
+                const sigs = getSortedSigs(script, partialSig);
+                unlockingScript = opcat_1.Script.fromASM(`OP_0 ${sigs.map(sig => tools.toHex(sig)).join(' ')}`);
+                break;
+            }
+        case 'pubkey':
+            {
+                const ls = opcat_1.Script.fromBuffer(Buffer.from(script));
+                if (ls.isPublicKeyOut()) {
+                    unlockingScript = opcat_1.Script.fromASM(`${tools.toHex(partialSig[0].signature)}}`);
+                }
+                else {
+                    throw new Error('Can not finalize pubkey script, it is not a valid public key script');
+                }
+                break;
+            }
+        case 'pubkeyhash':
+            {
+                const ls = opcat_1.Script.fromBuffer(Buffer.from(script));
+                if (ls.isPublicKeyHashOut()) {
+                    unlockingScript = opcat_1.Script.fromASM(`${tools.toHex(partialSig[0].signature)} ${tools.toHex(partialSig[0].pubkey)}`);
+                }
+                else {
+                    throw new Error('Can not finalize pubkey script, it is not a valid public key hash script');
+                }
+                break;
+            }
+    }
+    return unlockingScript;
+}
+function getScriptFromInput(_inputIndex, input, _cache) {
+    const res = {
+        script: null,
+    };
+    res.script = input.opcatUtxo.script;
+    return res;
+}
+function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
+    const input = (0, bip174_2.checkForInput)(inputs, inputIndex);
+    if (!input.bip32Derivation || input.bip32Derivation.length === 0) {
+        throw new Error('Need bip32Derivation to sign with HD');
+    }
+    const myDerivations = input.bip32Derivation
+        .map((bipDv) => {
+        if (tools.compare(bipDv.masterFingerprint, hdKeyPair.fingerprint) === 0) {
+            return bipDv;
+        }
+        else {
+            return undefined;
+        }
+    })
+        .filter((v) => !!v);
+    if (myDerivations.length === 0) {
+        throw new Error('Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint');
+    }
+    const signers = myDerivations.map(bipDv => {
+        const node = hdKeyPair.derivePath(bipDv.path);
+        if (tools.compare(bipDv.pubkey, node.publicKey) !== 0) {
+            throw new Error('pubkey did not match bip32Derivation');
+        }
+        return node;
+    });
+    return signers;
+}
+function getSortedSigs(script, partialSig) {
+    const ss = opcat_1.Script.fromBuffer(Buffer.from(script));
+    const p2ms = ss.decodeMultisigOut();
+    // for each pubkey in order of p2ms script
+    return p2ms
+        .pubkeys.map(pk => {
+        // filter partialSig array by pubkey being equal
+        return (partialSig.filter(ps => {
+            return tools.compare(ps.pubkey, pk) === 0;
+        })[0] || {}).signature;
+        // Any pubkey without a match will return undefined
+        // this last filter removes all the undefined items in the array.
+    })
+        .filter(v => !!v);
+}
+function sighashTypeToString(sighashType) {
+    let text = sighashType & opcat_1.crypto.Signature.SIGHASH_ANYONECANPAY
+        ? 'SIGHASH_ANYONECANPAY | '
+        : '';
+    const sigMod = sighashType & 0x1f;
+    switch (sigMod) {
+        case opcat_1.crypto.Signature.SIGHASH_ALL:
+            text += 'SIGHASH_ALL';
+            break;
+        case opcat_1.crypto.Signature.SIGHASH_SINGLE:
+            text += 'SIGHASH_SINGLE';
+            break;
+        case opcat_1.crypto.Signature.SIGHASH_NONE:
+            text += 'SIGHASH_NONE';
+            break;
+    }
+    return text;
+}
+function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize) {
+    let inputAmount = 0n;
+    inputs.forEach((input, idx) => {
+        if (mustFinalize && input.finalScriptSig)
+            tx.inputs[idx].setScript(opcat_1.Script.fromBuffer(Buffer.from(input.finalScriptSig)));
+        const out = tx.inputs[idx].output;
+        inputAmount += BigInt(out.satoshis);
+    });
+    const outputAmount = tx.outputs.reduce((total, o) => total + BigInt(o.satoshis), 0n);
+    const fee = inputAmount - outputAmount;
+    if (fee < 0) {
+        throw new Error('Outputs are spending more than Inputs');
+    }
+    const bytes = tx.getEstimateSize();
+    cache.__FEE = fee;
+    cache.__EXTRACTED_TX = tx;
+    cache.__FEE_RATE = Math.floor(Number(fee / BigInt(bytes)));
+}
+function getScriptFromUtxo(inputIndex, input, cache) {
+    const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
+    return script;
+}
+function getScriptAndAmountFromUtxo(inputIndex, _input, cache) {
+    const unsignedTx = cache.__TX;
+    const o = unsignedTx.inputs[inputIndex].output;
+    return { script: o.script.toBuffer(), value: BigInt(o.satoshis), data: o.data };
+}
+function pubkeyInInput(pubkey, input, inputIndex, cache) {
+    const script = getScriptFromUtxo(inputIndex, input, cache);
+    const { meaningfulScript } = getMeaningfulScript(script);
+    return (0, psbtutils_js_1.pubkeyInScript)(pubkey, meaningfulScript);
+}
+function pubkeyInOutput(pubkey, outputIndex, cache) {
+    // const script = cache.__TX.outputs[outputIndex].script;
+    // const { meaningfulScript } = getMeaningfulScript(
+    //   script.toBuffer(),
+    // );
+    // return pubkeyInScript(pubkey, meaningfulScript);
+    return true;
+}
+function compressPubkey(pubkey) {
+    if (pubkey.length === 65) {
+        const parity = pubkey[64] & 1;
+        const newKey = pubkey.slice(0, 33);
+        newKey[0] = 2 | parity;
+        return newKey;
+    }
+    return pubkey.slice();
+}
+function getMeaningfulScript(script) {
+    return {
+        meaningfulScript: script,
+        type: 'raw',
+    };
+}
+function classifyScript(script) {
+    const _script = opcat_1.Script.fromBuffer(Buffer.from(script));
+    if (_script.isPublicKeyHashOut())
+        return 'pubkeyhash';
+    if (_script.isMultisigOut())
+        return 'multisig';
+    if (_script.isPublicKeyOut)
+        return 'pubkey';
+    return 'nonstandard';
+}
+function range(n) {
+    return [...Array(n).keys()];
+}
+//# sourceMappingURL=psbt.js.map