@teleportdao/bitcoin 3.0.3 → 4.0.0-alpha.0

package/dist/transaction-builder/transaction-builder.js

@@ -15,66 +15,54 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTransactionBuilder = exports.DUST = exports.componentBytes = void 0;
+exports.BaseTransactionBuilder = void 0;
 const bitcoin = __importStar(require("bitcoinjs-lib"));
 const bitcoin_utils_1 = require("../bitcoin-utils");
-const coinselect = require("coinselect");
-const coinselectSplit = require("coinselect/split");
-const coinselectAccumulative = require("coinselect/accumulative");
-exports.componentBytes = {
-    bytePerInput: {
-        p2pkh: 148,
-        p2wpkh: 68,
-        "p2sh-p2wpkh": 91,
-        p2tr: 58,
-        default: 100,
-    },
-    baseTxBytes: 10 + 5,
-    bytePerOutput: {
-        p2pkh: 34,
-        p2wpkh: 31,
-        p2sh: 32,
-        p2tr: 43,
-        default: 35,
-        max: 45,
-    },
-    scriptExtraBytes: {
-        lessThan255: 12,
-        moreThan255: 15,
-    },
-};
-exports.DUST = 1000;
-function coinSelectInOrder(utxos, outputs, feeRate) {
-    let response = coinselectAccumulative(utxos, outputs, 1);
-    return Object.assign(Object.assign({}, response), { fee: +(+response.fee * feeRate).toFixed() });
-}
+const coin_select_1 = require("./coin-select");
+const SINGLESIG_TYPES = ["p2pkh", "p2wpkh", "p2sh-p2wpkh", "p2tr"];
+const MULTISIG_TYPES = ["p2sh", "p2wsh", "p2sh-p2wsh"];
 class BaseTransactionBuilder {
+    MULTISIG_TYPES = MULTISIG_TYPES;
+    testnet;
+    network;
+    maximumNumberOfOutputsInTransaction;
+    feeMin;
+    dustLimit;
+    NO_RBF_SEQUENCE = 0xffffffff;
     constructor({ network, testnet, feeMin = 0, dustLimit, maximumNumberOfOutputsInTransaction = 50, }) {
-        this.NO_RBF_SEQUENCE = 0xffffffff;
         this.testnet = testnet;
         this.network = network;
         this.maximumNumberOfOutputsInTransaction = maximumNumberOfOutputsInTransaction;
         this.feeMin = feeMin;
-        this.dustLimit = dustLimit || 1 * 2 * exports.componentBytes.bytePerInput.p2pkh;
+        this.dustLimit = dustLimit || 1 * 2 * coin_select_1.componentBytes.bytePerInput.p2pkh;
+    }
+    isMultiSig(addressType) {
+        return this.MULTISIG_TYPES.includes(addressType);
     }
     createAddressObject(input) {
+        if (this.MULTISIG_TYPES.includes(input.addressType))
+            return (0, bitcoin_utils_1.createMultisigAddressObjectByPublicKeys)(input.addressType, {
+                publicKeys: input.publicKeys,
+                numberOfSigners: input.numberOfSigners,
+            });
         return (0, bitcoin_utils_1.createAddressObjectByPublicKey)(input, this.network);
     }
     validateAddress(address) {
@@ -99,77 +87,32 @@ class BaseTransactionBuilder {
         };
     }
     calculateTxSize(inputTypes, outputs, changeAddressType = "default") {
-        const inputsSizes = inputTypes.map((addressType) => exports.componentBytes.bytePerInput[addressType]);
-        const outputSizes = outputs.map((outP) => {
-            if (outP.address) {
-                let addressType = "default";
-                try {
-                    addressType = (0, bitcoin_utils_1.getAddressType)(outP.address, this.network);
-                }
-                catch (_a) {
-                    addressType = "default";
-                }
-                return exports.componentBytes.bytePerOutput[addressType];
-            }
-            if (outP.script) {
-                if (outP.script.byteLength < 255) {
-                    return outP.script.byteLength + exports.componentBytes.scriptExtraBytes.lessThan255;
-                }
-                return outP.script.byteLength + exports.componentBytes.scriptExtraBytes.moreThan255;
-            }
-            return exports.componentBytes.bytePerOutput[changeAddressType];
-        });
-        const txSize = exports.componentBytes.baseTxBytes +
-            inputsSizes.reduce((a, c) => a + c, 0) +
-            outputSizes.reduce((a, c) => a + c, 0);
-        return txSize;
+        return (0, coin_select_1.calculateTxSize)(inputTypes, outputs, changeAddressType, this.network);
     }
-    helperHandleInputsAndOutputs({ targets, extendedUtxo, feeRate, changeObject, selectType = "normal", }) {
-        const filteredUtxo = extendedUtxo.filter((u) => u.value >
-            +feeRate *
-                exports.componentBytes.bytePerInput[u.signerInfo.addressType]);
-        let selectResponse;
-        switch (selectType) {
-            case "normal":
-                selectResponse = coinselect(filteredUtxo, targets, Math.round(feeRate));
-                break;
-            case "accumulative":
-                selectResponse = coinselectAccumulative(filteredUtxo, targets, Math.round(feeRate));
-                break;
-            case "inOrder":
-                selectResponse = coinSelectInOrder(filteredUtxo, targets, Math.round(feeRate));
-                break;
-            case "full":
-                if (!targets[0].address) {
-                    throw new Error();
-                }
-                selectResponse = coinselectSplit(filteredUtxo, [{ address: targets[0].address }], Math.round(feeRate));
-                break;
-            default:
-                break;
-        }
-        let { inputs, outputs, fee, } = selectResponse;
-        if (!inputs || !outputs) {
-            inputs = filteredUtxo;
-            outputs = targets;
-            fee = inputs.reduce((a, b) => a + b.value, 0) - outputs.reduce((a, b) => a + b.value, 0);
-        }
-        let changeAddressType = "default";
-        try {
-            changeAddressType = (0, bitcoin_utils_1.getAddressType)((changeObject === null || changeObject === void 0 ? void 0 : changeObject.address) || "", this.network);
-        }
-        catch (_a) {
-            changeAddressType = "default";
+    oldTxFeeCheck(newInputs, newOutputs, newChange, newFee, changeObject, feeRate, selectType, changeAddressType) {
+        let inputs = newInputs.slice();
+        let outputs = newOutputs.slice();
+        let fee = newFee;
+        if (newChange) {
+            outputs.push({
+                value: newChange.value,
+            });
         }
-        const txSize = this.calculateTxSize(inputs.map((i) => i.signerInfo.addressType), outputs, changeAddressType) + exports.componentBytes.bytePerOutput.default;
+        const txSize = this.calculateTxSize(inputs.map((i) => ({
+            addressType: i.signerInfo.addressType,
+            m: i.signerInfo.publicKeys?.length,
+            n: i.signerInfo.numberOfSigners,
+        })), outputs, changeAddressType);
+        let extraChangeFee = Math.round(coin_select_1.componentBytes.bytePerOutput.default * feeRate);
         let txFee = Math.round(txSize * feeRate);
-        if (Math.round(feeRate) === 1) {
-            txFee = Math.round(txFee + txFee * 0.1);
+        if (feeRate === 1) {
+            txFee = Math.round(1.1 * txFee);
         }
         if (inputs.reduce((a, b) => a + b.value, 0) -
             outputs.filter((o) => o.address || o.script).reduce((a, b) => a + b.value, 0) -
-            txFee <
-            0) {
+            txFee -
+            extraChangeFee <
+            -1 * coin_select_1.DUST) {
             let spendableBalance = inputs.reduce((a, b) => a + b.value, 0);
             let totalOutputAmount = outputs
                 .filter((o) => o.address || o.script)
@@ -178,131 +121,293 @@ class BaseTransactionBuilder {
             throw new Error(`not enough balance. details: ${JSON.stringify({ spendableBalance, totalOutputAmount, txFee, need }, null, 2)}`);
         }
         let diff = fee - txFee;
-        let changeIndex = outputs.findIndex((x) => !(x === null || x === void 0 ? void 0 : x.address) && !x.script && (x.value || 0) > 0);
+        if (Math.abs(diff) >= coin_select_1.DUST) {
+            console.log("diff", diff, "fee", fee, "txFee", txFee);
+        }
+        let changeIndex = outputs.findIndex((x) => !x?.address && !x.script && (x.value || 0) > 0);
         let change;
-        if (changeIndex >= 0 || diff > exports.DUST) {
+        if (diff > 0) {
             if (changeIndex >= 0) {
-                diff = diff + exports.componentBytes.bytePerOutput.default * Math.round(feeRate);
-            }
-            if (diff < 0) {
-                diff = 0;
-            }
-            if (selectType === "full") {
-                outputs[0].value = outputs[0].value + diff;
+                if (!changeObject)
+                    throw new Error("change not exist");
+                change = {
+                    address: changeObject.address,
+                    value: outputs[changeIndex].value + diff,
+                };
                 fee = fee - diff;
             }
-            else {
+            else if (diff - extraChangeFee > coin_select_1.DUST) {
                 if (!changeObject)
                     throw new Error("change not exist");
                 change = {
                     address: changeObject.address,
-                    value: changeIndex >= 0 ? outputs[changeIndex].value + diff : diff,
+                    value: diff - extraChangeFee,
                 };
-                fee = fee - diff;
+                fee = fee - diff + extraChangeFee;
             }
-            if (changeIndex >= 0) {
-                outputs.splice(changeIndex, 1);
+        }
+        else if (-1 * diff > 0) {
+            const positiveDiff = -1 * diff;
+            let currentChangeValue = changeIndex > 0 ? outputs[changeIndex].value : -1 * extraChangeFee;
+            if (currentChangeValue - positiveDiff < -1 * coin_select_1.DUST) {
+                throw new Error(`not enough balance.`);
+            }
+            if (changeIndex > 0) {
+                if (!changeObject)
+                    throw new Error("change not exist");
+                change =
+                    outputs[changeIndex].value - positiveDiff > coin_select_1.DUST
+                        ? {
+                            address: changeObject.address,
+                            value: outputs[changeIndex].value - positiveDiff,
+                        }
+                        : undefined;
+                fee = fee + positiveDiff;
+            }
+        }
+        else if (changeIndex > 0) {
+            if (!changeObject)
+                throw new Error("change not exist");
+            change = {
+                address: changeObject.address,
+                value: outputs[changeIndex].value,
+            };
+        }
+        if (changeIndex >= 0) {
+            outputs.splice(changeIndex, 1);
+        }
+        if (Math.abs(fee - newFee) > coin_select_1.DUST) {
+            console.log("fee", fee);
+            console.log("newFee", newFee);
+            throw new Error("fee mismatch");
+        }
+        let totalOutputValue = outputs.reduce((a, b) => a + b.value, 0);
+        let totalNewOutputValue = newOutputs.reduce((a, b) => a + b.value, 0);
+        if (totalOutputValue - totalNewOutputValue !== 0) {
+            console.log("totalOutputValue", totalOutputValue);
+            console.log("totalNewOutputValue", totalNewOutputValue);
+            console.log("diff", totalOutputValue - totalNewOutputValue);
+            throw new Error("output value mismatch");
+        }
+        if (outputs.length !== newOutputs.length) {
+            console.log("outputs", outputs);
+            console.log("newOutputs", newOutputs);
+            throw new Error("output length mismatch");
+        }
+        for (let i = 0; i < outputs.length; i += 1) {
+            if (outputs[i].value !== newOutputs[i].value) {
+                console.log("outputs[i].value", outputs[i].value);
+                console.log("newOutputs[i].value", newOutputs[i].value);
+                throw new Error("output value mismatch");
+            }
+            if (outputs[i].address !== newOutputs[i].address) {
+                console.log("outputs[i].address", outputs[i].address);
+                console.log("newOutputs[i].address", newOutputs[i].address);
+                throw new Error("output address mismatch");
+            }
+            if (outputs[i].script !== newOutputs[i].script) {
+                console.log("outputs[i].script", outputs[i].script);
+                console.log("newOutputs[i].script", newOutputs[i].script);
+                throw new Error("output script mismatch");
             }
         }
+        let totalInputValue = inputs.reduce((a, b) => a + b.value, 0);
+        let totalNewInputValue = newInputs.reduce((a, b) => a + b.value, 0);
+        if (Math.abs(totalInputValue - (change?.value || 0) - (totalNewInputValue - (newChange?.value || 0))) > coin_select_1.DUST) {
+            console.log("totalInputValue", totalInputValue);
+            throw new Error("input value mismatch");
+        }
+        return { inputs, outputs, change, fee };
+    }
+    helperHandleInputsAndOutputs({ requiredUtxo, targets, extendedUtxo, feeRate, changeObject, selectType = "normal", }) {
+        const filteredUtxo = selectType !== "inOrder"
+            ? extendedUtxo.filter((u) => u.value >
+                +feeRate *
+                    (0, coin_select_1.getInputSize)(u.signerInfo.addressType, {
+                        m: u.signerInfo.publicKeys?.length,
+                        n: u.signerInfo.numberOfSigners,
+                    }) +
+                    coin_select_1.DUST)
+            : extendedUtxo;
+        let changeAddressType = "default";
+        try {
+            changeAddressType = (0, bitcoin_utils_1.getAddressType)(changeObject.address || "", this.network);
+        }
+        catch {
+            changeAddressType = "default";
+        }
+        let selectResponse;
+        let newFeeRate = feeRate === 1 ? 1.1 : feeRate;
+        switch (selectType) {
+            case "normal":
+                selectResponse = (0, coin_select_1.coinSelectNormal)(filteredUtxo, targets, newFeeRate, changeAddressType, this.network, 5, requiredUtxo, {
+                    minInputCount: 10,
+                    maxInputValue: 0.003 * 1e8,
+                });
+                break;
+            case "inOrder":
+                selectResponse = (0, coin_select_1.coinSelectAccumulative)(filteredUtxo, targets, newFeeRate, changeAddressType, this.network);
+                break;
+            case "full":
+                selectResponse = (0, coin_select_1.coinSelectAll)(filteredUtxo, targets, newFeeRate, changeAddressType, this.network);
+                break;
+            default:
+                throw new Error("invalid select type");
+        }
+        let { success, inputs, outputs, change: changeValue, fee, totalInputValue, totalOutputValue, needed, } = selectResponse;
+        let change;
+        if (changeValue) {
+            change = {
+                address: changeObject.address,
+                value: changeValue.value,
+            };
+        }
+        if (!success || needed < 0) {
+            throw new Error(`not enough balance. details: ${JSON.stringify({ totalInputValue, totalOutputValue, fee, needed }, null, 2)}`);
+        }
+        this.oldTxFeeCheck(inputs, outputs, change, fee, changeObject, feeRate, selectType, changeAddressType);
         return {
             inputs,
             fee,
-            outputs: outputs,
+            outputs,
             change,
         };
     }
-    filterAndConvertTxDataToStandardFormat({ extendedUtxo, targets, changeObject, feeRate, selectType, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let { inputs: filteredInputs, outputs, change, fee, } = this.helperHandleInputsAndOutputs({
-                targets,
-                extendedUtxo,
-                feeRate,
-                changeObject,
-                selectType,
-            });
-            let inputs = yield this.convertExtendedUtxoToInputs(filteredInputs);
-            return {
-                inputs,
-                outputs,
-                change,
-                fee,
-                feeRate,
-            };
+    async filterAndConvertTxDataToStandardFormat({ extendedUtxo, requiredUtxo, targets, changeObject, feeRate, selectType, }) {
+        let { inputs: filteredInputs, outputs, change, fee, } = this.helperHandleInputsAndOutputs({
+            requiredUtxo,
+            targets,
+            extendedUtxo,
+            feeRate,
+            changeObject,
+            selectType,
         });
+        let inputs = await this.convertExtendedUtxoToInputs(filteredInputs);
+        return {
+            inputs,
+            outputs,
+            change,
+            fee,
+            feeRate,
+        };
     }
-    convertExtendedUtxoToInputs(baseInputs = []) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let inputs = baseInputs;
-            const transactionHex = {};
-            for (let i in inputs) {
-                let { address, publicKey, derivationPath, masterFingerprint, addressType } = inputs[i].signerInfo;
-                let addressObject = this.createAddressObject({
-                    publicKey: Buffer.from(publicKey, "hex"),
-                    addressType,
-                });
-                if (derivationPath && masterFingerprint && addressObject.pubkey) {
-                    inputs[i].bip32Derivation = [
-                        {
-                            path: derivationPath,
-                            pubkey: addressObject.pubkey,
-                            masterFingerprint: Buffer.from(masterFingerprint, "hex"),
-                        },
-                    ];
+    async convertExtendedUtxoToInputs(baseInputs = []) {
+        let inputs = baseInputs;
+        const transactionHex = {};
+        for (let i in inputs) {
+            let { address, publicKey, derivationPath, masterFingerprint, addressType, publicKeys, numberOfSigners, } = inputs[i].signerInfo;
+            let addressObject = this.createAddressObject({
+                publicKey: Buffer.from(publicKey, "hex"),
+                publicKeys: publicKeys?.map((p) => Buffer.from(p, "hex")),
+                numberOfSigners,
+                addressType,
+            });
+            if (derivationPath && masterFingerprint && addressObject.pubkey) {
+                inputs[i].bip32Derivation = [
+                    {
+                        path: derivationPath,
+                        pubkey: addressObject.pubkey,
+                        masterFingerprint: Buffer.from(masterFingerprint, "hex"),
+                    },
+                ];
+            }
+            if (addressType === "p2pkh") {
+                const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
+                transactionHex[inputs[i].hash] = txHex;
+                inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
+            }
+            else if (addressType === "p2wpkh") {
+                if (!addressObject.output)
+                    throw new Error("invalid signer info");
+                inputs[i].witnessUtxo = {
+                    script: addressObject.output,
+                    value: inputs[i].value,
+                };
+                if (inputs[i].signerInfo.includeHex) {
+                    const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
+                    transactionHex[inputs[i].hash] = txHex;
+                    inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
                 }
-                if (addressType === "p2pkh") {
-                    const txHex = transactionHex[inputs[i].hash] || (yield this._getTransactionHex(inputs[i].hash));
+            }
+            else if (addressType === "p2sh-p2wpkh") {
+                if (!addressObject.output)
+                    throw new Error("invalid signer info");
+                inputs[i].witnessUtxo = {
+                    script: addressObject.output,
+                    value: inputs[i].value,
+                };
+                if (!addressObject?.redeem?.output)
+                    throw new Error("invalid signer info for p2sh-p2wpkh address");
+                inputs[i].redeemScript = addressObject.redeem.output;
+                if (inputs[i].signerInfo.includeHex) {
+                    const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
                     transactionHex[inputs[i].hash] = txHex;
                     inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
                 }
-                else if (addressType === "p2wpkh") {
-                    if (!addressObject.output)
-                        throw new Error("invalid signer info");
-                    inputs[i].witnessUtxo = {
-                        script: addressObject.output,
-                        value: inputs[i].value,
-                    };
-                    if (inputs[i].signerInfo.includeHex) {
-                        const txHex = transactionHex[inputs[i].hash] || (yield this._getTransactionHex(inputs[i].hash));
-                        transactionHex[inputs[i].hash] = txHex;
-                        inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
-                    }
+            }
+            else if (addressType === "p2tr") {
+                if (!addressObject.output)
+                    throw new Error("invalid signer info");
+                inputs[i].witnessUtxo = {
+                    script: addressObject.output,
+                    value: inputs[i].value,
+                };
+                if (!addressObject.pubkey)
+                    throw new Error("invalid signer info for p2tr address (pubkey)");
+                inputs[i].tapInternalKey = addressObject.internalPubkey;
+                if (inputs[i].signerInfo.includeHex) {
+                    const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
+                    transactionHex[inputs[i].hash] = txHex;
+                    inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
                 }
-                else if (addressType === "p2sh-p2wpkh") {
-                    if (!addressObject.output)
-                        throw new Error("invalid signer info");
-                    inputs[i].witnessUtxo = {
-                        script: addressObject.output,
-                        value: inputs[i].value,
-                    };
-                    if (!((_a = addressObject === null || addressObject === void 0 ? void 0 : addressObject.redeem) === null || _a === void 0 ? void 0 : _a.output))
-                        throw new Error("invalid signer info for p2sh address");
-                    inputs[i].redeemScript = addressObject.redeem.output;
-                    if (inputs[i].signerInfo.includeHex) {
-                        const txHex = transactionHex[inputs[i].hash] || (yield this._getTransactionHex(inputs[i].hash));
-                        transactionHex[inputs[i].hash] = txHex;
-                        inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
-                    }
+            }
+            else if (addressType === "p2sh") {
+                const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
+                transactionHex[inputs[i].hash] = txHex;
+                inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
+                if (!addressObject.output)
+                    throw new Error("invalid signer info");
+                if (!addressObject?.redeem?.output)
+                    throw new Error("invalid signer info for p2sh address");
+                inputs[i].redeemScript = addressObject.redeem.output;
+            }
+            else if (addressType === "p2wsh") {
+                if (!addressObject.output)
+                    throw new Error("invalid signer info");
+                inputs[i].witnessUtxo = {
+                    script: addressObject.output,
+                    value: inputs[i].value,
+                };
+                if (!addressObject?.redeem?.output)
+                    throw new Error("invalid signer info for p2wsh address");
+                inputs[i].witnessScript = addressObject.redeem?.output;
+                if (inputs[i].signerInfo.includeHex) {
+                    const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
+                    transactionHex[inputs[i].hash] = txHex;
+                    inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
                 }
-                else if (addressType === "p2tr") {
-                    if (!addressObject.output)
-                        throw new Error("invalid signer info");
-                    inputs[i].witnessUtxo = {
-                        script: addressObject.output,
-                        value: inputs[i].value,
-                    };
-                    if (!addressObject.pubkey)
-                        throw new Error("invalid signer info for p2tr address (pubkey)");
-                    inputs[i].tapInternalKey = addressObject.internalPubkey;
-                    if (inputs[i].signerInfo.includeHex) {
-                        const txHex = transactionHex[inputs[i].hash] || (yield this._getTransactionHex(inputs[i].hash));
-                        transactionHex[inputs[i].hash] = txHex;
-                        inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
-                    }
+            }
+            else if (addressType === "p2sh-p2wsh") {
+                if (!addressObject.output)
+                    throw new Error("invalid signer info");
+                inputs[i].witnessUtxo = {
+                    script: addressObject.output,
+                    value: inputs[i].value,
+                };
+                if (!addressObject?.redeem?.output)
+                    throw new Error("invalid signer info for p2sh address");
+                inputs[i].redeemScript = addressObject.redeem.output;
+                if (!addressObject?.redeem?.redeem?.output)
+                    throw new Error("invalid signer info for p2sh-p2wsh address");
+                inputs[i].witnessScript = addressObject.redeem.redeem.output;
+                if (inputs[i].signerInfo.includeHex) {
+                    const txHex = transactionHex[inputs[i].hash] || (await this._getTransactionHex(inputs[i].hash));
+                    transactionHex[inputs[i].hash] = txHex;
+                    inputs[i].nonWitnessUtxo = Buffer.from(txHex, "hex");
                 }
             }
-            return inputs;
-        });
+        }
+        return inputs;
     }
     createUnsignedTransaction({ inputs, outputs, change, fee, feeRate, sequenceNumber, }) {
         const sequence = sequenceNumber || this.NO_RBF_SEQUENCE - 2;
@@ -310,88 +415,55 @@ class BaseTransactionBuilder {
         const newPsbt = new bitcoin.Psbt({ network });
         newPsbt.setMaximumFeeRate(+(feeRate + feeRate / 100).toFixed());
         for (const input of inputs) {
-            let { addressType } = input.signerInfo;
-            switch (addressType) {
-                case "p2pkh": {
-                    let i = {
-                        hash: input.hash,
-                        index: Number(input.index),
-                        nonWitnessUtxo: input.nonWitnessUtxo,
-                        sequence,
-                        bip32Derivation: input.bip32Derivation,
-                    };
-                    if (!i.bip32Derivation)
-                        delete i.bip32Derivation;
-                    newPsbt.addInput(i);
-                    break;
-                }
-                case "p2wpkh": {
-                    let i = {
-                        hash: input.hash,
-                        index: Number(input.index),
-                        witnessUtxo: input.witnessUtxo,
-                        nonWitnessUtxo: input.nonWitnessUtxo,
-                        sequence,
-                        bip32Derivation: input.bip32Derivation,
-                    };
-                    if (!i.bip32Derivation)
-                        delete i.bip32Derivation;
-                    if (!i.nonWitnessUtxo)
-                        delete i.nonWitnessUtxo;
-                    newPsbt.addInput(i);
-                    break;
-                }
-                case "p2sh-p2wpkh": {
-                    let i = {
-                        hash: input.hash,
-                        index: Number(input.index),
-                        witnessUtxo: input.witnessUtxo,
-                        nonWitnessUtxo: input.nonWitnessUtxo,
-                        redeemScript: input.redeemScript,
-                        sequence,
-                        bip32Derivation: input.bip32Derivation,
-                    };
-                    if (!i.bip32Derivation)
-                        delete i.bip32Derivation;
-                    if (!i.nonWitnessUtxo)
-                        delete i.nonWitnessUtxo;
-                    newPsbt.addInput(i);
-                    break;
-                }
-                case "p2tr": {
-                    let i = {
-                        hash: input.hash,
-                        index: Number(input.index),
-                        witnessUtxo: input.witnessUtxo,
-                        nonWitnessUtxo: input.nonWitnessUtxo,
-                        tapInternalKey: input.tapInternalKey,
-                        sequence,
-                        bip32Derivation: input.bip32Derivation,
-                    };
-                    if (!i.bip32Derivation)
-                        delete i.bip32Derivation;
-                    if (!i.nonWitnessUtxo)
-                        delete i.nonWitnessUtxo;
-                    newPsbt.addInput(i);
-                    break;
-                }
-                default:
-                    throw new Error("address type is incorrect");
-            }
+            const i = {
+                hash: input.hash,
+                index: +input.index,
+                witnessUtxo: input.witnessUtxo,
+                nonWitnessUtxo: input.nonWitnessUtxo,
+                redeemScript: input.redeemScript,
+                sequence,
+                bip32Derivation: input.bip32Derivation,
+                witnessScript: input.witnessScript,
+                tapInternalKey: input.tapInternalKey,
+            };
+            if (!i.bip32Derivation)
+                delete i.bip32Derivation;
+            if (!i.nonWitnessUtxo)
+                delete i.nonWitnessUtxo;
+            if (!i.witnessUtxo)
+                delete i.witnessUtxo;
+            if (!i.redeemScript)
+                delete i.redeemScript;
+            if (!i.witnessScript)
+                delete i.witnessScript;
+            if (!i.tapInternalKey)
+                delete i.tapInternalKey;
+            newPsbt.addInput(i);
         }
         for (const target of outputs) {
-            newPsbt.addOutput(target);
+            if (target.address) {
+                newPsbt.addOutput({ address: target.address, value: target.value });
+            }
+            else if (target.script) {
+                newPsbt.addOutput({ script: target.script, value: target.value });
+            }
+            else {
+                throw new Error("invalid target");
+            }
         }
-        if (change && Object.keys(change).length !== 0) {
+        if (change) {
             newPsbt.addOutput(change);
         }
-        if (change && Object.keys(change).length !== 0) {
+        if (change) {
             if (newPsbt.txOutputs[outputs.length].address !== change.address) {
                 throw new Error("error change address");
             }
+            if (newPsbt.txOutputs[outputs.length].value !== change.value) {
+                throw new Error("error change value");
+            }
         }
         const unsignedPsbtBaseText = newPsbt.toBase64();
-        const safeAddressTypeForPossibleTxId = ["p2wpkh", "p2tr"];
+        const safeAddressTypeForPossibleTxId = ["p2wpkh", "p2tr", "p2wsh"];
         const isPossibleTxId = inputs.reduce((a, b) => a && safeAddressTypeForPossibleTxId.includes(b.signerInfo.addressType), true);
         return {
             unsignedTransaction: unsignedPsbtBaseText,
@@ -403,36 +475,47 @@ class BaseTransactionBuilder {
                 signerInfo: utx.signerInfo,
             })),
             fee,
+            feeRate,
             change,
             possibleTxId: isPossibleTxId ? this.getUnsignedPsbtTxId(unsignedPsbtBaseText) : undefined,
         };
     }
-    processUnsignedTransaction({ extendedUtxo, targets = [], changeAddress = undefined, fullAmount = false, feeRate, selectType = "normal", sequenceNumber, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!changeAddress && targets.length === 0)
-                throw new Error("no target");
-            let changeObject = typeof changeAddress === "string"
-                ? {
-                    address: changeAddress,
-                }
-                : changeAddress;
-            const { inputs, outputs, change, fee } = yield this.filterAndConvertTxDataToStandardFormat({
-                extendedUtxo,
-                targets,
-                changeObject,
-                feeRate,
-                selectType: fullAmount ? "full" : selectType,
-            });
-            let unsignedTransaction = this.createUnsignedTransaction({
-                inputs,
-                outputs,
-                change,
-                fee,
-                feeRate,
-                sequenceNumber,
-            });
-            return unsignedTransaction;
+    async processUnsignedTransaction({ extendedUtxo, targets = [], changeAddress = undefined, fullAmount = false, feeRate, selectType = "normal", sequenceNumber, requiredUtxo, }) {
+        let changeObject;
+        if (selectType === "full") {
+            if (targets.length !== 1 || !targets[0].address)
+                throw new Error("invalid targets");
+            changeObject = {
+                address: targets[0].address,
+            };
+        }
+        else {
+            if (!changeAddress)
+                throw new Error("no change address");
+            changeObject =
+                typeof changeAddress === "string"
+                    ? {
+                        address: changeAddress,
+                    }
+                    : changeAddress;
+        }
+        const { inputs, outputs, change, fee } = await this.filterAndConvertTxDataToStandardFormat({
+            requiredUtxo,
+            extendedUtxo,
+            targets,
+            changeObject,
+            feeRate,
+            selectType: fullAmount ? "full" : selectType,
+        });
+        let unsignedTransaction = this.createUnsignedTransaction({
+            inputs,
+            outputs,
+            change,
+            fee,
+            feeRate,
+            sequenceNumber,
         });
+        return unsignedTransaction;
     }
     getUnsignedPsbtTxId(unsignedPsbt) {
         let psbt = bitcoin.Psbt.fromBase64(unsignedPsbt, {
@@ -440,6 +523,9 @@ class BaseTransactionBuilder {
         });
         return psbt.__CACHE.__TX.getId();
     }
+    getTxFromHex(hex) {
+        return bitcoin.Transaction.fromHex(hex);
+    }
 }
 exports.BaseTransactionBuilder = BaseTransactionBuilder;
 //# sourceMappingURL=transaction-builder.js.map