@atomicfinance/bitcoin-dlc-provider 3.5.0 → 3.5.1

package/lib/BitcoinDlcProvider.js

@@ -0,0 +1,2027 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_1 = __importDefault(require("@atomicfinance/provider"));
+const types_1 = require("@atomicfinance/types");
+const utils_1 = require("@atomicfinance/utils");
+const core_1 = require("@node-dlc/core");
+const messaging_1 = require("@node-dlc/messaging");
+const bitcoin_1 = require("@node-lightning/bitcoin");
+const bufio_1 = require("@node-lightning/bufio");
+const crypto_1 = require("@node-lightning/crypto");
+const assert_1 = __importDefault(require("assert"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const bitcoin_networks_1 = require("bitcoin-networks");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const Utils_1 = require("./utils/Utils");
+class BitcoinDlcProvider extends provider_1.default {
+    constructor(network, cfdDlcJs) {
+        super();
+        this._network = network;
+        this._cfdDlcJs = cfdDlcJs;
+    }
+    async CfdLoaded() {
+        while (!this._cfdDlcJs) {
+            await (0, utils_1.sleep)(10);
+        }
+    }
+    async GetPrivKeysForInputs(inputs) {
+        const privKeys = [];
+        for (let i = 0; i < inputs.length; i++) {
+            const input = inputs[i];
+            let derivationPath = input.derivationPath;
+            if (!derivationPath) {
+                derivationPath = (await this.getMethod('getWalletAddress')(input.address)).derivationPath;
+            }
+            const keyPair = await this.getMethod('keyPair')(derivationPath);
+            const privKey = Buffer.from(keyPair.__D).toString('hex');
+            privKeys.push(privKey);
+        }
+        return privKeys;
+    }
+    async GetCfdNetwork() {
+        const network = await this.getConnectedNetwork();
+        switch (network.name) {
+            case 'bitcoin_testnet':
+                return 'testnet';
+            case 'bitcoin_regtest':
+                return 'regtest';
+            default:
+                return 'bitcoin';
+        }
+    }
+    async GetInputsForAmount(amounts, feeRatePerVb, fixedInputs = []) {
+        if (amounts.length === 0)
+            return [];
+        const fixedUtxos = fixedInputs.map((input) => input.toUtxo());
+        let inputs;
+        try {
+            const inputsForAmount = await this.getMethod('getInputsForDualFunding')(amounts, feeRatePerVb, fixedUtxos);
+            inputs = inputsForAmount.inputs;
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+            if (fixedInputs.length === 0) {
+                throw Error(`Not enough balance getInputsForAmount. Error: ${errorMessage}`);
+            }
+            else {
+                inputs = fixedInputs;
+            }
+        }
+        return inputs;
+    }
+    async Initialize(collateral, feeRatePerVb, fixedInputs) {
+        const network = await this.getConnectedNetwork();
+        const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+        const payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+        const changeAddress = await this.client.wallet.getUnusedAddress(true);
+        const changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+        const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+        const fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+        if (fundingAddress.address === payoutAddress.address)
+            throw Error('Address reuse');
+        const inputs = await this.GetInputsForAmount([collateral], feeRatePerVb, fixedInputs);
+        const fundingInputs = await Promise.all(inputs.map(async (input) => {
+            return this.inputToFundingInput(input);
+        }));
+        const payoutSerialId = (0, Utils_1.generateSerialId)();
+        const changeSerialId = (0, Utils_1.generateSerialId)();
+        return {
+            fundingPubKey,
+            payoutSPK,
+            payoutSerialId,
+            fundingInputs,
+            changeSPK,
+            changeSerialId,
+        };
+    }
+    async BatchInitialize(collaterals, feeRatePerVb, fixedInputs) {
+        const network = await this.getConnectedNetwork();
+        const inputs = await this.GetInputsForAmount(collaterals, feeRatePerVb, fixedInputs);
+        const fundingInputs = await Promise.all(inputs.map(async (input) => {
+            return this.inputToFundingInput(input);
+        }));
+        const initializeResponses = [];
+        const changeSerialId = (0, Utils_1.generateSerialId)();
+        const changeAddress = await this.client.wallet.getUnusedAddress(true);
+        const changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+        for (let i = 0; i < collaterals.length; i++) {
+            const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+            const payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+            const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+            const fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+            if (fundingAddress.address === payoutAddress.address)
+                throw Error('Address reuse');
+            const payoutSerialId = (0, Utils_1.generateSerialId)();
+            initializeResponses.push({
+                fundingPubKey,
+                payoutSPK,
+                payoutSerialId,
+            });
+        }
+        return { fundingInputs, initializeResponses, changeSerialId, changeSPK };
+    }
+    /**
+     * TODO: Add GetPayoutFromOutcomes
+     *
+     * private GetPayoutsFromOutcomes(
+     *   contractDescriptor: ContractDescriptorV0,
+     *   totalCollateral: bigint,
+     * ): PayoutRequest[] {}
+     */
+    GetPayoutsFromPayoutFunction(_dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        if (_dlcOffer.type !== messaging_1.MessageType.DlcOfferV0)
+            throw Error('DlcOffer must be V0');
+        const dlcOffer = _dlcOffer;
+        if (contractDescriptor.payoutFunction.type !== messaging_1.MessageType.PayoutFunctionV0)
+            throw Error('PayoutFunction must be V0');
+        const payoutFunction = contractDescriptor.payoutFunction;
+        if (payoutFunction.pieces.length === 0)
+            throw Error('PayoutFunction must have at least once PayoutCurvePiece');
+        if (payoutFunction.pieces.length > 1)
+            throw Error('More than one PayoutCurvePiece not supported');
+        const payoutCurvePiece = payoutFunction.pieces[0]
+            .payoutCurvePiece;
+        if (payoutCurvePiece.type !== messaging_1.MessageType.HyperbolaPayoutCurvePiece &&
+            payoutCurvePiece.type !== messaging_1.MessageType.OldHyperbolaPayoutCurvePiece)
+            throw Error('Must be HyperbolaPayoutCurvePiece');
+        if (payoutCurvePiece.b !== BigInt(0) || payoutCurvePiece.c !== BigInt(0))
+            throw Error('b and c HyperbolaPayoutCurvePiece values must be 0');
+        const eventDescriptor = oracleInfo.announcement.oracleEvent
+            .eventDescriptor;
+        if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptorV0)
+            throw Error('Only DigitDecomposition Oracle Events supported');
+        const roundingIntervals = contractDescriptor.roundingIntervals;
+        const cetPayouts = core_1.HyperbolaPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
+        const payoutGroups = [];
+        cetPayouts.forEach((p) => {
+            payoutGroups.push({
+                payout: p.payout,
+                groups: (0, core_1.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
+            });
+        });
+        const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateralSatoshis, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis, true);
+        return { payouts, payoutGroups, messagesList };
+    }
+    GetPayoutsFromPolynomialPayoutFunction(_dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        if (_dlcOffer.type !== messaging_1.MessageType.DlcOfferV0)
+            throw Error('DlcOffer must be V0');
+        const dlcOffer = _dlcOffer;
+        if (contractDescriptor.payoutFunction.type !== messaging_1.MessageType.PayoutFunctionV0)
+            throw Error('PayoutFunction must be V0');
+        const payoutFunction = contractDescriptor.payoutFunction;
+        if (payoutFunction.pieces.length === 0)
+            throw Error('PayoutFunction must have at least once PayoutCurvePiece');
+        for (const piece of payoutFunction.pieces) {
+            if (piece.payoutCurvePiece.type !== messaging_1.MessageType.PolynomialPayoutCurvePiece)
+                throw Error('Must be PolynomialPayoutCurvePiece');
+        }
+        const eventDescriptor = oracleInfo.announcement.oracleEvent
+            .eventDescriptor;
+        if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptorV0)
+            throw Error('Only DigitDecomposition Oracle Events supported');
+        const roundingIntervals = contractDescriptor.roundingIntervals;
+        const cetPayouts = core_1.PolynomialPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
+        const payoutGroups = [];
+        cetPayouts.forEach((p) => {
+            payoutGroups.push({
+                payout: p.payout,
+                groups: (0, core_1.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
+            });
+        });
+        const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateralSatoshis, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis, true);
+        return { payouts, payoutGroups, messagesList };
+    }
+    GetPayouts(_dlcOffer) {
+        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+        const contractInfo = dlcOffer.contractInfo;
+        const totalCollateral = contractInfo.totalCollateral;
+        const contractOraclePairs = this.GetContractOraclePairs(contractInfo);
+        const payoutResponses = contractOraclePairs.map(({ contractDescriptor, oracleInfo }) => this.GetPayoutsFromContractDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral));
+        return payoutResponses;
+    }
+    FlattenPayouts(payoutResponses) {
+        return payoutResponses.reduce((acc, { payouts, payoutGroups, messagesList }) => {
+            return {
+                payouts: acc.payouts.concat(payouts),
+                payoutGroups: acc.payoutGroups.concat(payoutGroups),
+                messagesList: acc.messagesList.concat(messagesList),
+            };
+        });
+    }
+    GetIndicesFromPayouts(payoutResponses) {
+        return payoutResponses.reduce((prev, acc) => {
+            return prev.concat({
+                startingMessagesIndex: prev[prev.length - 1].startingMessagesIndex +
+                    acc.messagesList.length,
+                startingPayoutGroupsIndex: prev[prev.length - 1].startingPayoutGroupsIndex +
+                    acc.payoutGroups.length,
+            });
+        }, [{ startingMessagesIndex: 0, startingPayoutGroupsIndex: 0 }]);
+    }
+    GetPayoutsFromContractDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        switch (contractDescriptor.type) {
+            case messaging_1.MessageType.ContractDescriptorV0: {
+                throw Error('ContractDescriptorV0 not yet supported');
+            }
+            case messaging_1.MessageType.ContractDescriptorV1:
+                {
+                    const contractDescriptorV1 = contractDescriptor;
+                    const payoutFunction = contractDescriptorV1.payoutFunction;
+                    // TODO: add a better check for this
+                    const payoutCurvePiece = payoutFunction.pieces[0].payoutCurvePiece;
+                    switch (payoutCurvePiece.type) {
+                        case messaging_1.MessageType.HyperbolaPayoutCurvePiece:
+                            return this.GetPayoutsFromPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
+                        case messaging_1.MessageType.OldHyperbolaPayoutCurvePiece:
+                            return this.GetPayoutsFromPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
+                        case messaging_1.MessageType.PolynomialPayoutCurvePiece:
+                            return this.GetPayoutsFromPolynomialPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
+                    }
+                }
+                break;
+            default: {
+                throw Error('ContractDescriptor must be V0 or V1');
+            }
+        }
+    }
+    async createDlcTxs(_dlcOffer, _dlcAccept) {
+        const { dlcOffer, dlcAccept } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+        });
+        const localFundPubkey = dlcOffer.fundingPubKey.toString('hex');
+        const remoteFundPubkey = dlcAccept.fundingPubKey.toString('hex');
+        const localFinalScriptPubkey = dlcOffer.payoutSPK.toString('hex');
+        const remoteFinalScriptPubkey = dlcAccept.payoutSPK.toString('hex');
+        const localChangeScriptPubkey = dlcOffer.changeSPK.toString('hex');
+        const remoteChangeScriptPubkey = dlcAccept.changeSPK.toString('hex');
+        const localInputs = await Promise.all(dlcOffer.fundingInputs.map(async (fundingInput) => {
+            const input = await this.fundingInputToInput(fundingInput, false);
+            return input.toUtxo();
+        }));
+        const remoteInputs = await Promise.all(dlcAccept.fundingInputs.map(async (fundingInput) => {
+            const input = await this.fundingInputToInput(fundingInput, false);
+            return input.toUtxo();
+        }));
+        const localInputAmount = localInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        const remoteInputAmount = remoteInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        const payoutResponses = this.GetPayouts(dlcOffer);
+        const { payouts, messagesList } = this.FlattenPayouts(payoutResponses);
+        const dlcTxRequest = {
+            payouts,
+            localFundPubkey,
+            localFinalScriptPubkey,
+            remoteFundPubkey,
+            remoteFinalScriptPubkey,
+            localInputAmount,
+            localCollateralAmount: dlcOffer.offerCollateralSatoshis,
+            localPayoutSerialId: dlcOffer.payoutSerialId,
+            localChangeSerialId: dlcOffer.changeSerialId,
+            remoteInputAmount,
+            remoteCollateralAmount: dlcAccept.acceptCollateralSatoshis,
+            remotePayoutSerialId: dlcAccept.payoutSerialId,
+            remoteChangeSerialId: dlcAccept.changeSerialId,
+            refundLocktime: dlcOffer.refundLocktime,
+            localInputs,
+            remoteInputs,
+            localChangeScriptPubkey,
+            remoteChangeScriptPubkey,
+            feeRate: Number(dlcOffer.feeRatePerVb),
+            cetLockTime: dlcOffer.cetLocktime,
+            fundOutputSerialId: dlcOffer.fundOutputSerialId,
+        };
+        const dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+        const dlcTransactions = new messaging_1.DlcTransactionsV0();
+        dlcTransactions.fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.fundTxHex));
+        dlcTransactions.fundTxVout = [
+            BigInt(dlcOffer.changeSerialId),
+            BigInt(dlcAccept.changeSerialId),
+            BigInt(dlcTxRequest.fundOutputSerialId),
+        ]
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+            .findIndex((i) => BigInt(i) === BigInt(dlcTxRequest.fundOutputSerialId));
+        dlcTransactions.refundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.refundTxHex));
+        dlcTransactions.cets = dlcTxs.cetsHex.map((cetHex) => {
+            return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cetHex));
+        });
+        return { dlcTransactions, messagesList };
+    }
+    async createBatchDlcTxs(_dlcOffers, _dlcAccepts) {
+        const dlcOffers = _dlcOffers.map((dlcOffer) => {
+            return (0, Utils_1.checkTypes)({ _dlcOffer: dlcOffer }).dlcOffer;
+        });
+        const dlcAccepts = _dlcAccepts.map((dlcAccept) => {
+            return (0, Utils_1.checkTypes)({ _dlcAccept: dlcAccept }).dlcAccept;
+        });
+        const localFundPubkeys = dlcOffers.map((dlcOffer) => dlcOffer.fundingPubKey.toString('hex'));
+        const remoteFundPubkeys = dlcAccepts.map((dlcAccept) => dlcAccept.fundingPubKey.toString('hex'));
+        const localFinalScriptPubkeys = dlcOffers.map((dlcOffer) => dlcOffer.payoutSPK.toString('hex'));
+        const remoteFinalScriptPubkeys = dlcAccepts.map((dlcAccept) => dlcAccept.payoutSPK.toString('hex'));
+        const localChangeScriptPubkey = dlcOffers[0].changeSPK.toString('hex');
+        const remoteChangeScriptPubkey = dlcAccepts[0].changeSPK.toString('hex');
+        const localInputs = await Promise.all(dlcOffers[0].fundingInputs.map(async (fundingInput) => {
+            const input = await this.fundingInputToInput(fundingInput, false);
+            return input.toUtxo();
+        }));
+        const remoteInputs = await Promise.all(dlcAccepts[0].fundingInputs.map(async (fundingInput) => {
+            const input = await this.fundingInputToInput(fundingInput, false);
+            return input.toUtxo();
+        }));
+        const localInputAmount = localInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        const remoteInputAmount = remoteInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        const localPayouts = [];
+        const remotePayouts = [];
+        const numPayouts = [];
+        const nestedMessagesList = [];
+        // loop through all dlc offers, get payouts, and add to localPayouts and remotePayouts
+        for (const dlcOffer of dlcOffers) {
+            const payoutResponses = this.GetPayouts(dlcOffer);
+            const { payouts, messagesList } = this.FlattenPayouts(payoutResponses);
+            const tempLocalPayouts = payouts.map((payout) => payout.local);
+            const tempRemotePayouts = payouts.map((payout) => payout.remote);
+            localPayouts.push(...tempLocalPayouts);
+            remotePayouts.push(...tempRemotePayouts);
+            numPayouts.push(tempLocalPayouts.length);
+            nestedMessagesList.push(messagesList);
+        }
+        const batchDlcTxRequest = {
+            localPayouts,
+            remotePayouts,
+            numPayouts,
+            localFundPubkeys,
+            localFinalScriptPubkeys,
+            remoteFundPubkeys,
+            remoteFinalScriptPubkeys,
+            localInputAmount,
+            localCollateralAmounts: dlcOffers.map((dlcOffer) => dlcOffer.offerCollateralSatoshis),
+            localPayoutSerialIds: dlcOffers.map((dlcOffer) => dlcOffer.payoutSerialId),
+            localChangeSerialId: dlcOffers[0].changeSerialId,
+            remoteInputAmount,
+            remoteCollateralAmounts: dlcAccepts.map((dlcAccept) => dlcAccept.acceptCollateralSatoshis),
+            remotePayoutSerialIds: dlcAccepts.map((dlcAccept) => dlcAccept.payoutSerialId),
+            remoteChangeSerialId: dlcAccepts[0].changeSerialId,
+            refundLocktimes: dlcOffers.map((dlcOffer) => dlcOffer.refundLocktime),
+            localInputs,
+            remoteInputs,
+            localChangeScriptPubkey,
+            remoteChangeScriptPubkey,
+            feeRate: Number(dlcOffers[0].feeRatePerVb),
+            cetLockTime: dlcOffers[0].cetLocktime,
+            fundOutputSerialIds: dlcOffers.map((dlcOffer) => dlcOffer.fundOutputSerialId),
+        };
+        const dlcTxs = await this.CreateBatchDlcTransactions(batchDlcTxRequest);
+        const dlcTransactionsList = [];
+        let start = 0;
+        for (let i = 0; i < dlcTxs.refundTxHexList.length; i++) {
+            const dlcTransactions = new messaging_1.DlcTransactionsV0();
+            dlcTransactions.fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.fundTxHex));
+            dlcTransactions.fundTxVout = [
+                BigInt(dlcOffers[i].changeSerialId),
+                BigInt(dlcAccepts[i].changeSerialId),
+                ...dlcOffers.map((dlcOffer) => dlcOffer.fundOutputSerialId),
+            ]
+                .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+                .findIndex((j) => BigInt(j) === BigInt(dlcOffers[i].fundOutputSerialId));
+            dlcTransactions.refundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.refundTxHexList[i]));
+            // slice cetsHexList based on numPayouts
+            const end = start + Number(numPayouts[i]);
+            const cetsHexList = dlcTxs.cetsHexList.slice(start, end);
+            start = end;
+            dlcTransactions.cets = cetsHexList.map((cetHex) => {
+                return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cetHex));
+            });
+            dlcTransactionsList.push(dlcTransactions);
+        }
+        return { dlcTransactionsList, nestedMessagesList };
+    }
+    GenerateEnumMessages(oracleEvent) {
+        throw Error('Only DigitDecomposition Oracle Events supported');
+    }
+    GenerateDigitDecompositionMessages(oracleEvent) {
+        const oracleNonces = oracleEvent.oracleNonces;
+        const eventDescriptor = oracleEvent.eventDescriptor;
+        const messagesList = [];
+        oracleNonces.forEach(() => {
+            const messages = [];
+            for (let i = 0; i < eventDescriptor.base; i++) {
+                const m = i.toString();
+                messages.push(m);
+            }
+            messagesList.push({ messages });
+        });
+        return messagesList;
+    }
+    GenerateMessages(oracleInfo) {
+        const oracleEvent = oracleInfo.announcement.oracleEvent;
+        switch (oracleEvent.eventDescriptor.type) {
+            case messaging_1.MessageType.EnumEventDescriptorV0:
+                return this.GenerateEnumMessages(oracleEvent);
+            case messaging_1.MessageType.DigitDecompositionEventDescriptorV0:
+                return this.GenerateDigitDecompositionMessages(oracleEvent);
+            default:
+                throw Error('EventDescriptor must be Enum or DigitDecomposition');
+        }
+    }
+    GetContractOraclePairs(_contractInfo) {
+        switch (_contractInfo.type) {
+            case messaging_1.MessageType.ContractInfoV0: {
+                const contractInfo = _contractInfo;
+                return [
+                    {
+                        contractDescriptor: contractInfo.contractDescriptor,
+                        oracleInfo: contractInfo.oracleInfo,
+                    },
+                ];
+            }
+            case messaging_1.MessageType.ContractInfoV1: {
+                return _contractInfo.contractOraclePairs;
+            }
+            default:
+                throw Error('ContractInfo must be V0 or V1');
+        }
+    }
+    async CreateCetAdaptorAndRefundSigs(_dlcOffer, _dlcAccept, _dlcTxs, messagesList, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        const network = await this.getConnectedNetwork();
+        const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
+        const fundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubKey : dlcAccept.fundingPubKey))
+            .serialize()
+            .slice(1);
+        const fundingAddress = bitcoinjs_lib_1.address.fromOutputScript(fundingSPK, network);
+        const { derivationPath } = await this.client.wallet.findAddress([
+            fundingAddress,
+        ]);
+        const fundPrivateKeyPair = await this.getMethod('keyPair')(derivationPath);
+        const fundPrivateKey = Buffer.from(fundPrivateKeyPair.__D).toString('hex');
+        const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
+        const indices = this.GetIndicesFromPayouts(this.GetPayouts(_dlcOffer));
+        const sigs = [];
+        for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
+            const oracleAnnouncement = oracleInfo.announcement;
+            const startingIndex = indices[index].startingMessagesIndex, endingIndex = indices[index + 1].startingMessagesIndex;
+            const oracleEventMessagesList = messagesList.slice(startingIndex, endingIndex);
+            const oracleEventCetsHex = cetsHex.slice(startingIndex, endingIndex);
+            const chunk = 100;
+            const adaptorSigRequestPromises = [];
+            for (let i = 0, j = oracleEventMessagesList.length; i < j; i += chunk) {
+                const tempMessagesList = oracleEventMessagesList.slice(i, i + chunk);
+                const tempCetsHex = oracleEventCetsHex.slice(i, i + chunk);
+                const cetSignRequest = {
+                    messagesList: tempMessagesList,
+                    cetsHex: tempCetsHex,
+                    privkey: fundPrivateKey,
+                    fundTxId: dlcTxs.fundTx.txId.toString(),
+                    fundVout: dlcTxs.fundTxVout,
+                    localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
+                    remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
+                    oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
+                };
+                adaptorSigRequestPromises.push((async () => {
+                    const response = await this.CreateCetAdaptorSignatures(cetSignRequest);
+                    return response.adaptorPairs;
+                })());
+            }
+            const adaptorPairs = (await Promise.all(adaptorSigRequestPromises)).flat();
+            sigs.push(adaptorPairs.map((adaptorPair) => {
+                return {
+                    encryptedSig: Buffer.from(adaptorPair.signature, 'hex'),
+                    dleqProof: Buffer.from(adaptorPair.proof, 'hex'),
+                };
+            }));
+        }
+        const refundSignRequest = {
+            refundTxHex: dlcTxs.refundTx.serialize().toString('hex'),
+            privkey: fundPrivateKey,
+            fundTxId: dlcTxs.fundTx.txId.toString(),
+            fundVout: dlcTxs.fundTxVout,
+            localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
+            remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+            fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+        };
+        const refundSignature = Buffer.from((await this.GetRawRefundTxSignature(refundSignRequest)).hex, 'hex');
+        const cetSignatures = new messaging_1.CetAdaptorSignaturesV0();
+        cetSignatures.sigs = sigs.flat();
+        return { cetSignatures, refundSignature };
+    }
+    async VerifyCetAdaptorAndRefundSigs(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, messagesList, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
+        const chunk = 100;
+        const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
+        const indices = this.GetIndicesFromPayouts(this.GetPayouts(_dlcOffer));
+        for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
+            const oracleAnnouncement = oracleInfo.announcement;
+            const startingIndex = indices[index].startingMessagesIndex, endingIndex = indices[index + 1].startingMessagesIndex;
+            const oracleEventMessagesList = messagesList.slice(startingIndex, endingIndex);
+            const oracleEventCetsHex = cetsHex.slice(startingIndex, endingIndex);
+            const oracleEventSigs = (isOfferer
+                ? dlcAccept.cetSignatures.sigs
+                : dlcSign.cetSignatures.sigs).slice(startingIndex, endingIndex);
+            const sigsValidity = [];
+            for (let i = 0, j = oracleEventMessagesList.length; i < j; i += chunk) {
+                const tempMessagesList = oracleEventMessagesList.slice(i, i + chunk);
+                const tempCetsHex = oracleEventCetsHex.slice(i, i + chunk);
+                const tempSigs = oracleEventSigs.slice(i, i + chunk);
+                const tempAdaptorPairs = tempSigs.map((sig) => {
+                    return {
+                        signature: sig.encryptedSig.toString('hex'),
+                        proof: sig.dleqProof.toString('hex'),
+                    };
+                });
+                const verifyCetAdaptorSignaturesRequest = {
+                    cetsHex: tempCetsHex,
+                    messagesList: tempMessagesList,
+                    oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
+                    oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
+                    adaptorPairs: tempAdaptorPairs,
+                    localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
+                    remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                    fundTxId: dlcTxs.fundTx.txId.toString(),
+                    fundVout: dlcTxs.fundTxVout,
+                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    verifyRemote: isOfferer,
+                };
+                sigsValidity.push((async () => {
+                    const response = await this.VerifyCetAdaptorSignatures(verifyCetAdaptorSignaturesRequest);
+                    return response.valid;
+                })());
+            }
+            let areSigsValid = (await Promise.all(sigsValidity)).every((b) => b);
+            const verifyRefundSigRequest = {
+                refundTxHex: dlcTxs.refundTx.serialize().toString('hex'),
+                signature: isOfferer
+                    ? dlcAccept.refundSignature.toString('hex')
+                    : dlcSign.refundSignature.toString('hex'),
+                localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
+                remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                fundTxId: dlcTxs.fundTx.txId.toString(),
+                fundVout: dlcTxs.fundTxVout,
+                fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                verifyRemote: isOfferer,
+            };
+            areSigsValid =
+                areSigsValid &&
+                    (await this.VerifyRefundTxSignature(verifyRefundSigRequest)).valid;
+            if (!areSigsValid) {
+                throw new Error('Invalid signatures received');
+            }
+        }
+    }
+    async CreateFundingSigs(_dlcOffer, _dlcAccept, _dlcTxs, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        const fundingInputs = isOfferer
+            ? dlcOffer.fundingInputs
+            : dlcAccept.fundingInputs;
+        const inputs = await Promise.all(fundingInputs.map(async (fundingInput) => {
+            return this.fundingInputToInput(fundingInput);
+        }));
+        const inputPrivKeys = await this.GetPrivKeysForInputs(inputs);
+        const fundTxSigs = await Promise.all(inputs.map(async (input, index) => {
+            const fundTxSignRequest = {
+                fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+                privkey: inputPrivKeys[index],
+                prevTxId: input.txid,
+                prevVout: input.vout,
+                amount: input.value,
+            };
+            return (await this.GetRawFundTxSignature(fundTxSignRequest)).hex;
+        }));
+        const inputPubKeys = await Promise.all(inputPrivKeys.map(async (privkey) => {
+            const reqPrivKey = {
+                privkey,
+                isCompressed: true,
+            };
+            return (await this.getMethod('GetPubkeyFromPrivkey')(reqPrivKey))
+                .pubkey;
+        }));
+        const witnessElements = [];
+        for (let i = 0; i < fundTxSigs.length; i++) {
+            const sigWitness = new messaging_1.ScriptWitnessV0();
+            sigWitness.witness = Buffer.from(fundTxSigs[i], 'hex');
+            const pubKeyWitness = new messaging_1.ScriptWitnessV0();
+            pubKeyWitness.witness = Buffer.from(inputPubKeys[i], 'hex');
+            witnessElements.push([sigWitness, pubKeyWitness]);
+        }
+        const fundingSignatures = new messaging_1.FundingSignaturesV0();
+        fundingSignatures.witnessElements = witnessElements;
+        return fundingSignatures;
+    }
+    async VerifyFundingSigs(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        const sigsValidity = [];
+        for (let i = 0; i < dlcSign.fundingSignatures.witnessElements.length; i++) {
+            const witnessElement = dlcSign.fundingSignatures.witnessElements[i];
+            const signature = witnessElement[0].witness.toString('hex');
+            const pubkey = witnessElement[1].witness.toString('hex');
+            const fundingInput = isOfferer
+                ? dlcAccept.fundingInputs[i]
+                : dlcOffer.fundingInputs[i];
+            const verifyFundSigRequest = {
+                fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+                signature,
+                pubkey,
+                prevTxId: fundingInput.prevTx.txId.toString(),
+                prevVout: fundingInput.prevTxVout,
+                fundInputAmount: fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats,
+            };
+            sigsValidity.push((async () => {
+                const response = await this.VerifyFundTxSignature(verifyFundSigRequest);
+                return response.valid;
+            })());
+        }
+        const areSigsValid = (await Promise.all(sigsValidity)).every((b) => b);
+        if (!areSigsValid) {
+            throw new Error('Invalid signatures received');
+        }
+    }
+    async CreateFundingTx(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, fundingSignatures) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        const witnessElements = [
+            ...dlcSign.fundingSignatures.witnessElements,
+            ...fundingSignatures.witnessElements,
+        ];
+        const fundingInputs = [
+            ...dlcOffer.fundingInputs,
+            ...dlcAccept.fundingInputs,
+        ];
+        let fundTxHex = dlcTxs.fundTx.serialize().toString('hex');
+        await (0, Utils_1.asyncForEach)(witnessElements, async (witnessElement, i) => {
+            const signature = witnessElement[0].witness.toString('hex');
+            const pubkey = witnessElement[1].witness.toString('hex');
+            const fundingInput = fundingInputs[i];
+            const addSignRequest = {
+                fundTxHex,
+                signature,
+                prevTxId: fundingInput.prevTx.txId.toString(),
+                prevVout: fundingInput.prevTxVout,
+                pubkey,
+            };
+            fundTxHex = (await this.AddSignatureToFundTransaction(addSignRequest))
+                .hex;
+        });
+        const fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(fundTxHex));
+        return fundTx;
+    }
+    async FindOutcomeIndexFromPolynomialPayoutCurvePiece(_dlcOffer, contractDescriptor, contractOraclePairIndex, polynomialPayoutCurvePiece, oracleAttestation, outcome) {
+        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+        const polynomialCurve = core_1.PolynomialPayoutCurve.fromPayoutCurvePiece(polynomialPayoutCurvePiece);
+        const payouts = polynomialPayoutCurvePiece.points.map((point) => Number(point.outcomePayout));
+        const minPayout = Math.min(...payouts);
+        const maxPayout = Math.max(...payouts);
+        const clampBN = (val) => bignumber_js_1.default.max(minPayout, bignumber_js_1.default.min(val, maxPayout));
+        const payout = clampBN(polynomialCurve.getPayout(outcome));
+        const payoutResponses = this.GetPayouts(dlcOffer);
+        const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[contractOraclePairIndex].startingMessagesIndex;
+        const { payoutGroups } = payoutResponses[contractOraclePairIndex];
+        const intervalsSorted = [
+            ...contractDescriptor.roundingIntervals.intervals,
+        ].sort((a, b) => Number(b.beginInterval) - Number(a.beginInterval));
+        const interval = intervalsSorted.find((interval) => Number(outcome) >= Number(interval.beginInterval));
+        const roundedPayout = BigInt(clampBN(new bignumber_js_1.default((0, core_1.roundPayout)(payout, interval.roundingMod).toString())).toString());
+        const outcomesFormatted = oracleAttestation.outcomes.map((outcome) => parseInt(outcome));
+        let index = 0;
+        let groupIndex = -1;
+        let groupLength = 0;
+        for (const payoutGroup of payoutGroups) {
+            if (payoutGroup.payout === roundedPayout) {
+                groupIndex = payoutGroup.groups.findIndex((group) => {
+                    return group.every((msg, i) => msg === outcomesFormatted[i]);
+                });
+                if (groupIndex === -1)
+                    throw Error('Failed to Find OutcomeIndex From PolynomialPayoutCurvePiece. \
+Payout Group found but incorrect group index');
+                index += groupIndex;
+                groupLength = payoutGroup.groups[groupIndex].length;
+                break;
+            }
+            else {
+                index += payoutGroup.groups.length;
+            }
+        }
+        if (groupIndex === -1)
+            throw Error('Failed to Find OutcomeIndex From PolynomialPayoutCurvePiece. \
+Payout Group not found');
+        return { index: payoutIndexOffset + index, groupLength };
+    }
+    async FindOutcomeIndexFromHyperbolaPayoutCurvePiece(_dlcOffer, contractDescriptor, contractOraclePairIndex, hyperbolaPayoutCurvePiece, oracleAttestation, outcome) {
+        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+        const hyperbolaCurve = core_1.HyperbolaPayoutCurve.fromPayoutCurvePiece(hyperbolaPayoutCurvePiece);
+        const clampBN = (val) => bignumber_js_1.default.max(0, bignumber_js_1.default.min(val, dlcOffer.contractInfo.totalCollateral.toString()));
+        const payout = clampBN(hyperbolaCurve.getPayout(outcome));
+        const payoutResponses = this.GetPayouts(dlcOffer);
+        const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[contractOraclePairIndex].startingMessagesIndex;
+        const { payoutGroups } = payoutResponses[contractOraclePairIndex];
+        const intervalsSorted = [
+            ...contractDescriptor.roundingIntervals.intervals,
+        ].sort((a, b) => Number(b.beginInterval) - Number(a.beginInterval));
+        const interval = intervalsSorted.find((interval) => Number(outcome) >= Number(interval.beginInterval));
+        const roundedPayout = BigInt(clampBN(new bignumber_js_1.default((0, core_1.roundPayout)(payout, interval.roundingMod).toString())).toString());
+        const outcomesFormatted = oracleAttestation.outcomes.map((outcome) => parseInt(outcome));
+        let index = 0;
+        let groupIndex = -1;
+        let groupLength = 0;
+        for (const [i, payoutGroup] of payoutGroups.entries()) {
+            if (payoutGroup.payout === roundedPayout) {
+                groupIndex = payoutGroup.groups.findIndex((group) => {
+                    return group.every((msg, i) => msg === outcomesFormatted[i]);
+                });
+                if (groupIndex !== -1) {
+                    index += groupIndex;
+                    groupLength = payoutGroup.groups[groupIndex].length;
+                    break;
+                }
+            }
+            else if (payoutGroup.payout === BigInt(Math.round(Number(payout.toString()))) &&
+                i !== 0) {
+                // Edge case to account for case where payout is maximum payout for DLC
+                // But rounded payout does not round down
+                if (payoutGroups[i - 1].payout === roundedPayout) {
+                    // Ensure that the previous payout group causes index to be incremented
+                    index += payoutGroups[i - 1].groups.length;
+                }
+                groupIndex = payoutGroup.groups.findIndex((group) => {
+                    return group.every((msg, i) => msg === outcomesFormatted[i]);
+                });
+                if (groupIndex !== -1) {
+                    index += groupIndex;
+                    groupLength = payoutGroup.groups[groupIndex].length;
+                    break;
+                }
+            }
+            else {
+                index += payoutGroup.groups.length;
+            }
+        }
+        if (groupIndex === -1) {
+            throw Error('Failed to Find OutcomeIndex From HyperbolaPayoutCurvePiece. \
+Payout Group not found');
+        }
+        return { index: payoutIndexOffset + index, groupLength };
+    }
+    async FindOutcomeIndex(_dlcOffer, oracleAttestation) {
+        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+        const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
+        const contractOraclePairIndex = contractOraclePairs.findIndex(({ oracleInfo }) => oracleInfo.announcement.oracleEvent.eventId ===
+            oracleAttestation.eventId);
+        (0, assert_1.default)(contractOraclePairIndex !== -1, 'OracleAttestation must be for an existing OracleEvent');
+        const contractOraclePair = contractOraclePairs[contractOraclePairIndex];
+        const { contractDescriptor: _contractDescriptor, oracleInfo, } = contractOraclePair;
+        (0, assert_1.default)(_contractDescriptor.type === messaging_1.MessageType.ContractDescriptorV1, 'ContractDescriptor must be V1');
+        const contractDescriptor = _contractDescriptor;
+        const _payoutFunction = contractDescriptor.payoutFunction;
+        (0, assert_1.default)(_payoutFunction.type === messaging_1.MessageType.PayoutFunctionV0, 'PayoutFunction must be V0');
+        const eventDescriptor = oracleInfo.announcement.oracleEvent
+            .eventDescriptor;
+        const payoutFunction = _payoutFunction;
+        const base = eventDescriptor.base;
+        const outcome = [...oracleAttestation.outcomes]
+            .reverse()
+            .reduce((acc, val, i) => acc + Number(val) * base ** i, 0);
+        const piecesSorted = payoutFunction.pieces.sort((a, b) => Number(a.endpoint) - Number(b.endpoint));
+        const piece = piecesSorted.find((piece) => outcome < piece.endpoint);
+        switch (piece.payoutCurvePiece.type) {
+            case messaging_1.MessageType.PolynomialPayoutCurvePiece:
+                return this.FindOutcomeIndexFromPolynomialPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, piece.payoutCurvePiece, oracleAttestation, BigInt(outcome));
+            case messaging_1.MessageType.HyperbolaPayoutCurvePiece:
+                return this.FindOutcomeIndexFromHyperbolaPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, piece.payoutCurvePiece, oracleAttestation, BigInt(outcome));
+            case messaging_1.MessageType.OldHyperbolaPayoutCurvePiece:
+                return this.FindOutcomeIndexFromHyperbolaPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, piece.payoutCurvePiece, oracleAttestation, BigInt(outcome));
+            default:
+                throw Error('Must be Hyperbola or Polynomial curve piece');
+        }
+    }
+    ValidateEvent(_dlcOffer, oracleAttestation) {
+        const { dlcOffer } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+        });
+        switch (dlcOffer.contractInfo.type) {
+            case messaging_1.MessageType.ContractInfoV0: {
+                const contractInfo = dlcOffer.contractInfo;
+                switch (contractInfo.contractDescriptor.type) {
+                    case messaging_1.MessageType.ContractDescriptorV0:
+                        throw Error('ContractDescriptorV0 not yet supported');
+                    case messaging_1.MessageType.ContractDescriptorV1: {
+                        const oracleInfo = contractInfo.oracleInfo;
+                        if (oracleInfo.announcement.oracleEvent.eventId !==
+                            oracleAttestation.eventId)
+                            throw Error('Incorrect Oracle Attestation. Event Id must match.');
+                        break;
+                    }
+                    default:
+                        throw Error('ConractDescriptor must be V0 or V1');
+                }
+                break;
+            }
+            case messaging_1.MessageType.ContractInfoV1: {
+                const contractInfo = dlcOffer.contractInfo;
+                const attestedOracleEvent = contractInfo.contractOraclePairs.find(({ oracleInfo }) => oracleInfo.announcement.oracleEvent.eventId ===
+                    oracleAttestation.eventId);
+                if (!attestedOracleEvent)
+                    throw Error('Oracle event of attestation not found.');
+                break;
+            }
+            default:
+                throw Error('ContractInfo must be V0 or V1');
+        }
+    }
+    async FindAndSignCet(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, oracleAttestation, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        if (isOfferer === undefined)
+            isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
+        const { index: outcomeIndex, groupLength } = await this.FindOutcomeIndex(dlcOffer, oracleAttestation);
+        const fundPrivateKey = await this.GetFundPrivateKey(dlcOffer, dlcAccept, isOfferer);
+        const sliceIndex = -(oracleAttestation.signatures.length - groupLength);
+        const oracleSignatures = sliceIndex === 0
+            ? oracleAttestation.signatures
+            : oracleAttestation.signatures.slice(0, sliceIndex);
+        const signCetRequest = {
+            cetHex: dlcTxs.cets[outcomeIndex].serialize().toString('hex'),
+            fundPrivkey: fundPrivateKey,
+            fundTxId: dlcTxs.fundTx.txId.toString(),
+            fundVout: dlcTxs.fundTxVout,
+            localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
+            remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+            oracleSignatures: oracleSignatures.map((sig) => sig.toString('hex')),
+            fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+            adaptorSignature: isOfferer
+                ? dlcAccept.cetSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
+                : dlcSign.cetSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
+        };
+        const finalCet = (await this.SignCet(signCetRequest)).hex;
+        return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(finalCet));
+    }
+    async GetFundAddress(dlcOffer, dlcAccept, isOfferer) {
+        const network = await this.getConnectedNetwork();
+        const fundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubKey : dlcAccept.fundingPubKey))
+            .serialize()
+            .slice(1);
+        const fundingAddress = bitcoinjs_lib_1.address.fromOutputScript(fundingSPK, network);
+        return fundingAddress;
+    }
+    async GetFundKeyPair(dlcOffer, dlcAccept, isOfferer) {
+        const fundingAddress = await this.GetFundAddress(dlcOffer, dlcAccept, isOfferer);
+        const { derivationPath } = await this.getMethod('getWalletAddress')(fundingAddress);
+        const keyPair = await this.getMethod('keyPair')(derivationPath);
+        return keyPair;
+    }
+    async GetFundPrivateKey(dlcOffer, dlcAccept, isOfferer) {
+        const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, isOfferer);
+        return Buffer.from(fundPrivateKeyPair.privateKey).toString('hex');
+    }
+    async CreateCloseRawTxs(_dlcOffer, _dlcAccept, _dlcTxs, closeInputAmount, isOfferer, _dlcCloses = [], fundingInputs, initiatorPayouts) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        const network = await this.getConnectedNetwork();
+        let finalizer;
+        if (_dlcCloses.length === 0) {
+            finalizer = new core_1.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSPK, dlcAccept.payoutSPK, dlcOffer.feeRatePerVb);
+        }
+        const rawTransactionRequestPromises = [];
+        const rawCloseTxs = [];
+        const numPayouts = _dlcCloses.length === 0 ? initiatorPayouts.length : _dlcCloses.length;
+        for (let i = 0; i < numPayouts; i++) {
+            let offerPayoutValue = BigInt(0);
+            let acceptPayoutValue = BigInt(0);
+            if (_dlcCloses.length === 0) {
+                const payout = initiatorPayouts[i];
+                const payoutMinusOfferFees = finalizer.offerInitiatorFees > payout
+                    ? BigInt(0)
+                    : payout - finalizer.offerInitiatorFees;
+                const collateralMinusPayout = payout > dlcOffer.contractInfo.totalCollateral
+                    ? BigInt(0)
+                    : dlcOffer.contractInfo.totalCollateral - payout;
+                offerPayoutValue = isOfferer
+                    ? closeInputAmount + payoutMinusOfferFees
+                    : collateralMinusPayout;
+                acceptPayoutValue = isOfferer
+                    ? collateralMinusPayout
+                    : closeInputAmount + payoutMinusOfferFees;
+            }
+            else {
+                const dlcClose = (0, Utils_1.checkTypes)({ _dlcClose: _dlcCloses[i] }).dlcClose;
+                offerPayoutValue = dlcClose.offerPayoutSatoshis;
+                acceptPayoutValue = dlcClose.acceptPayoutSatoshis;
+            }
+            const txOuts = [];
+            if (Number(offerPayoutValue) > 0) {
+                txOuts.push({
+                    address: bitcoinjs_lib_1.address.fromOutputScript(dlcOffer.payoutSPK, network),
+                    amount: Number(offerPayoutValue),
+                });
+            }
+            if (Number(acceptPayoutValue) > 0) {
+                txOuts.push({
+                    address: bitcoinjs_lib_1.address.fromOutputScript(dlcAccept.payoutSPK, network),
+                    amount: Number(acceptPayoutValue),
+                });
+            }
+            if (dlcOffer.payoutSerialId > dlcAccept.payoutSerialId)
+                txOuts.reverse();
+            const rawTransactionRequest = {
+                version: 2,
+                locktime: 0,
+                txins: [
+                    {
+                        txid: dlcTxs.fundTx.txId.serialize().reverse().toString('hex'),
+                        vout: dlcTxs.fundTxVout,
+                        sequence: 0,
+                    },
+                ],
+                txouts: txOuts,
+            };
+            rawTransactionRequestPromises.push((async () => {
+                const response = await this.getMethod('CreateRawTransaction')(rawTransactionRequest);
+                return response.hex;
+            })());
+        }
+        const hexs = await Promise.all(rawTransactionRequestPromises);
+        rawCloseTxs.push(hexs);
+        return rawCloseTxs.flat();
+    }
+    async CreateSignatureHashes(_dlcOffer, _dlcAccept, _dlcTxs, rawCloseTxs) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        const network = await this.getConnectedNetwork();
+        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+            ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
+            : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+        const p2ms = bitcoinjs_lib_1.payments.p2ms({
+            m: 2,
+            pubkeys: fundingPubKeys,
+            network,
+        });
+        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
+            redeem: p2ms,
+            network,
+        });
+        const sigHashRequestPromises = [];
+        const sigHashes = [];
+        for (let i = 0; i < rawCloseTxs.length; i++) {
+            const rawTx = rawCloseTxs[i];
+            const sigHashRequest = {
+                tx: rawTx,
+                txin: {
+                    txid: dlcTxs.fundTx.txId.serialize().reverse().toString('hex'),
+                    vout: dlcTxs.fundTxVout,
+                    keyData: {
+                        hex: paymentVariant.redeem.output.toString('hex'),
+                        type: 'redeem_script',
+                    },
+                    amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                    hashType: 'p2wsh',
+                    sighashType: 'all',
+                    sighashAnyoneCanPay: false,
+                },
+            };
+            sigHashRequestPromises.push((async () => {
+                const response = await this.getMethod('CreateSignatureHash')(sigHashRequest);
+                return response.sighash;
+            })());
+        }
+        const sighashes = await Promise.all(sigHashRequestPromises);
+        sigHashes.push(sighashes);
+        return sigHashes.flat();
+    }
+    async CalculateEcSignatureHashes(sigHashes, privKey) {
+        const cfdNetwork = await this.GetCfdNetwork();
+        const sigsRequestPromises = [];
+        for (let i = 0; i < sigHashes.length; i++) {
+            const sigHash = sigHashes[i];
+            const calculateEcSignatureRequest = {
+                sighash: sigHash,
+                privkeyData: {
+                    privkey: privKey,
+                    wif: false,
+                    network: cfdNetwork,
+                },
+                isGrindR: true,
+            };
+            sigsRequestPromises.push((async () => {
+                const response = await this.getMethod('CalculateEcSignature')(calculateEcSignatureRequest);
+                return response.signature;
+            })());
+        }
+        const sigs = await Promise.all(sigsRequestPromises);
+        return sigs.flat();
+    }
+    async VerifySignatures(_dlcOffer, _dlcAccept, _dlcTxs, _dlcCloses, rawCloseTxs, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        const dlcCloses = _dlcCloses.map((_dlcClose) => (0, Utils_1.checkTypes)({ _dlcClose }).dlcClose);
+        const network = await this.getConnectedNetwork();
+        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+            ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
+            : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+        const p2ms = bitcoinjs_lib_1.payments.p2ms({
+            m: 2,
+            pubkeys: fundingPubKeys,
+            network,
+        });
+        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
+            redeem: p2ms,
+            network,
+        });
+        const pubkey = isOfferer ? dlcAccept.fundingPubKey : dlcOffer.fundingPubKey;
+        const sigsValidity = [];
+        for (let i = 0; i < rawCloseTxs.length; i++) {
+            const rawTx = rawCloseTxs[i];
+            const dlcClose = dlcCloses[i];
+            const verifySignatureRequest = {
+                tx: rawTx,
+                txin: {
+                    txid: dlcTxs.fundTx.txId.serialize().reverse().toString('hex'),
+                    vout: dlcTxs.fundTxVout,
+                    signature: dlcClose.closeSignature.toString('hex'),
+                    pubkey: pubkey.toString('hex'),
+                    redeemScript: paymentVariant.redeem.output.toString('hex'),
+                    hashType: 'p2wsh',
+                    sighashType: 'all',
+                    sighashAnyoneCanPay: false,
+                    amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                },
+            };
+            sigsValidity.push((async () => {
+                const response = await this.getMethod('VerifySignature')(verifySignatureRequest);
+                return response.success;
+            })());
+        }
+        const areSigsValid = (await Promise.all(sigsValidity)).every((b) => b);
+        return areSigsValid;
+    }
+    /**
+     * Check whether wallet is offerer of DlcOffer or DlcAccept
+     * @param dlcOffer Dlc Offer Message
+     * @param dlcAccept Dlc Accept Message
+     * @returns {Promise<boolean>}
+     */
+    async isOfferer(_dlcOffer, _dlcAccept) {
+        const { dlcOffer, dlcAccept } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+        });
+        const network = await this.getConnectedNetwork();
+        const offerFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(dlcOffer.fundingPubKey))
+            .serialize()
+            .slice(1);
+        const acceptFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(dlcAccept.fundingPubKey))
+            .serialize()
+            .slice(1);
+        const offerFundingAddress = bitcoinjs_lib_1.address.fromOutputScript(offerFundingSPK, network);
+        const acceptFundingAddress = bitcoinjs_lib_1.address.fromOutputScript(acceptFundingSPK, network);
+        let walletAddress = await this.client.wallet.findAddress([
+            offerFundingAddress,
+        ]);
+        if (walletAddress)
+            return true;
+        walletAddress = await this.client.wallet.findAddress([
+            acceptFundingAddress,
+        ]);
+        if (walletAddress)
+            return false;
+        throw Error('Wallet Address not found for DlcOffer or DlcAccept');
+    }
+    /**
+     * Create DLC Offer Message
+     * @param contractInfo ContractInfo TLV (V0 or V1)
+     * @param offerCollateralSatoshis Amount DLC Initiator is putting into the contract
+     * @param feeRatePerVb Fee rate in satoshi per virtual byte that both sides use to compute fees in funding tx
+     * @param cetLocktime The nLockTime to be put on CETs
+     * @param refundLocktime The nLockTime to be put on the refund transaction
+     * @returns {Promise<DlcOffer>}
+     */
+    async createDlcOffer(contractInfo, offerCollateralSatoshis, feeRatePerVb, cetLocktime, refundLocktime, fixedInputs) {
+        contractInfo.validate();
+        const network = await this.getConnectedNetwork();
+        const dlcOffer = new messaging_1.DlcOfferV0();
+        const { fundingPubKey, payoutSPK, payoutSerialId, fundingInputs: _fundingInputs, changeSPK, changeSerialId, } = await this.Initialize(offerCollateralSatoshis, feeRatePerVb, fixedInputs);
+        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        const fundingInputs = _fundingInputs.map((input) => input);
+        fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+        const fundOutputSerialId = (0, Utils_1.generateSerialId)();
+        (0, assert_1.default)(changeSerialId !== fundOutputSerialId, 'changeSerialId cannot equal the fundOutputSerialId');
+        dlcOffer.contractFlags = Buffer.from('00', 'hex');
+        dlcOffer.chainHash = (0, bitcoin_networks_1.chainHashFromNetwork)(network);
+        dlcOffer.contractInfo = contractInfo;
+        dlcOffer.fundingPubKey = fundingPubKey;
+        dlcOffer.payoutSPK = payoutSPK;
+        dlcOffer.payoutSerialId = payoutSerialId;
+        dlcOffer.offerCollateralSatoshis = offerCollateralSatoshis;
+        dlcOffer.fundingInputs = fundingInputs;
+        dlcOffer.changeSPK = changeSPK;
+        dlcOffer.changeSerialId = changeSerialId;
+        dlcOffer.fundOutputSerialId = dlcOffer.fundOutputSerialId = fundOutputSerialId;
+        dlcOffer.feeRatePerVb = feeRatePerVb;
+        dlcOffer.cetLocktime = cetLocktime;
+        dlcOffer.refundLocktime = refundLocktime;
+        (0, assert_1.default)((() => {
+            const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSPK, dlcOffer.changeSPK, null, null, null, dlcOffer.feeRatePerVb);
+            const funding = fundingInputs.reduce((total, input) => {
+                return total + input.prevTx.outputs[input.prevTxVout].value.sats;
+            }, BigInt(0));
+            return funding >= offerCollateralSatoshis + finalizer.offerFees;
+        })(), 'fundingInputs for dlcOffer must be greater than offerCollateralSatoshis plus offerFees');
+        dlcOffer.validate();
+        return dlcOffer;
+    }
+    async batchCreateDlcOffer(contractInfos, offerCollaterals, feeRatePerVb, cetLocktime, refundLocktimes, fixedInputs) {
+        if (contractInfos.length !== offerCollaterals.length ||
+            contractInfos.length !== refundLocktimes.length) {
+            throw new Error('The number of contractInfos, offerCollateralSatoshis, and refundLocktimes must be the same');
+        }
+        const dlcOffers = [];
+        for (let i = 0; i < contractInfos.length; i++) {
+            contractInfos[i].validate();
+        }
+        const network = await this.getConnectedNetwork();
+        const { fundingInputs: _fundingInputs, changeSPK, changeSerialId, initializeResponses, } = await this.BatchInitialize(offerCollaterals, feeRatePerVb, fixedInputs);
+        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        const fundingInputs = _fundingInputs.map((input) => input);
+        fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+        const fundOutputsSerialIds = (0, Utils_1.generateSerialIds)(contractInfos.length);
+        for (let i = 0; i < contractInfos.length; i++) {
+            const contractInfo = contractInfos[i];
+            const offerCollateralSatoshis = offerCollaterals[i];
+            const fundOutputSerialId = fundOutputsSerialIds[i];
+            const { fundingPubKey, payoutSPK, payoutSerialId } = initializeResponses[i];
+            const refundLocktime = refundLocktimes[i];
+            const dlcOffer = new messaging_1.DlcOfferV0();
+            dlcOffer.contractFlags = Buffer.from('00', 'hex');
+            dlcOffer.chainHash = (0, bitcoin_networks_1.chainHashFromNetwork)(network);
+            dlcOffer.contractInfo = contractInfo;
+            dlcOffer.fundingPubKey = fundingPubKey;
+            dlcOffer.payoutSPK = payoutSPK;
+            dlcOffer.payoutSerialId = payoutSerialId;
+            dlcOffer.offerCollateralSatoshis = offerCollateralSatoshis;
+            dlcOffer.fundingInputs = fundingInputs;
+            dlcOffer.changeSPK = changeSPK;
+            dlcOffer.changeSerialId = changeSerialId;
+            dlcOffer.fundOutputSerialId = fundOutputSerialId;
+            dlcOffer.feeRatePerVb = feeRatePerVb;
+            dlcOffer.cetLocktime = cetLocktime;
+            dlcOffer.refundLocktime = refundLocktime;
+            (0, assert_1.default)((() => {
+                const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSPK, dlcOffer.changeSPK, null, null, null, dlcOffer.feeRatePerVb);
+                const funding = fundingInputs.reduce((total, input) => {
+                    return total + input.prevTx.outputs[input.prevTxVout].value.sats;
+                }, BigInt(0));
+                return funding >= offerCollateralSatoshis + finalizer.offerFees;
+            })(), 'fundingInputs for dlcOffer must be greater than offerCollateralSatoshis plus offerFees');
+            dlcOffer.validate();
+            dlcOffers.push(dlcOffer);
+        }
+        return dlcOffers;
+    }
+    /**
+     * Accept DLC Offer
+     * @param _dlcOffer Dlc Offer Message
+     * @param fixedInputs Optional inputs to use for Funding Inputs
+     * @returns {Promise<AcceptDlcOfferResponse}
+     */
+    async acceptDlcOffer(_dlcOffer, fixedInputs) {
+        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+        dlcOffer.validate();
+        const acceptCollateralSatoshis = dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis;
+        (0, assert_1.default)(acceptCollateralSatoshis ===
+            dlcOffer.contractInfo.totalCollateral -
+                dlcOffer.offerCollateralSatoshis, 'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis');
+        const { fundingPubKey, payoutSPK, payoutSerialId, fundingInputs: _fundingInputs, changeSPK, changeSerialId, } = await this.Initialize(acceptCollateralSatoshis, dlcOffer.feeRatePerVb, fixedInputs);
+        (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubKey, fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
+        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        const fundingInputs = _fundingInputs.map((input) => input);
+        fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+        const dlcAccept = new messaging_1.DlcAcceptV0();
+        dlcAccept.tempContractId = (0, crypto_1.sha256)(dlcOffer.serialize());
+        dlcAccept.acceptCollateralSatoshis = acceptCollateralSatoshis;
+        dlcAccept.fundingPubKey = fundingPubKey;
+        dlcAccept.payoutSPK = payoutSPK;
+        dlcAccept.payoutSerialId = dlcAccept.payoutSerialId = payoutSerialId;
+        dlcAccept.fundingInputs = fundingInputs;
+        dlcAccept.changeSPK = changeSPK;
+        dlcAccept.changeSerialId = dlcAccept.changeSerialId = changeSerialId;
+        (0, assert_1.default)(dlcAccept.changeSerialId !== dlcOffer.fundOutputSerialId, 'changeSerialId cannot equal the fundOutputSerialId');
+        (0, assert_1.default)(dlcOffer.payoutSerialId !== dlcAccept.payoutSerialId, 'offer.payoutSerialId cannot equal accept.payoutSerialId');
+        (0, assert_1.default)((() => {
+            const ids = [
+                dlcOffer.changeSerialId,
+                dlcAccept.changeSerialId,
+                dlcOffer.fundOutputSerialId,
+            ];
+            return new Set(ids).size === ids.length;
+        })(), 'offer.changeSerialID, accept.changeSerialId and fundOutputSerialId must be unique');
+        dlcAccept.validate();
+        (0, assert_1.default)((() => {
+            const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSPK, dlcOffer.changeSPK, dlcAccept.fundingInputs, dlcAccept.payoutSPK, dlcAccept.changeSPK, dlcOffer.feeRatePerVb);
+            const funding = fundingInputs.reduce((total, input) => {
+                return total + input.prevTx.outputs[input.prevTxVout].value.sats;
+            }, BigInt(0));
+            return funding >= acceptCollateralSatoshis + finalizer.acceptFees;
+        })(), 'fundingInputs for dlcAccept must be greater than acceptCollateralSatoshis plus acceptFees');
+        const { dlcTransactions, messagesList } = await this.createDlcTxs(dlcOffer, dlcAccept);
+        const { cetSignatures, refundSignature, } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
+        (0, assert_1.default)(dlcTransactions.type === messaging_1.MessageType.DlcTransactionsV0, 'DlcTransactions must be V0');
+        const _dlcTransactions = dlcTransactions;
+        const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.tempContractId);
+        _dlcTransactions.contractId = contractId;
+        dlcAccept.cetSignatures = cetSignatures;
+        dlcAccept.refundSignature = refundSignature;
+        dlcAccept.negotiationFields = new messaging_1.NegotiationFieldsV0();
+        return { dlcAccept, dlcTransactions: _dlcTransactions };
+    }
+    async batchAcceptDlcOffer(_dlcOffers, fixedInputs) {
+        const dlcOffers = _dlcOffers.map((_dlcOffer) => {
+            const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+            dlcOffer.validate();
+            return dlcOffer;
+        });
+        const acceptCollaterals = dlcOffers.map((dlcOffer) => dlcOffer.contractInfo.totalCollateral -
+            dlcOffer.offerCollateralSatoshis);
+        const { fundingInputs: _fundingInputs, changeSPK, changeSerialId, initializeResponses, } = await this.BatchInitialize(acceptCollaterals, dlcOffers[0].feeRatePerVb, fixedInputs);
+        // Check that none of the funding pubkeys are the same between the
+        // dlcOffers and the dlcAccepts (from initializeResponses)
+        dlcOffers.forEach((dlcOffer) => {
+            initializeResponses.forEach((initializeResponse) => {
+                (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubKey, initializeResponse.fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
+            });
+        });
+        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        const fundingInputs = _fundingInputs.map((input) => input);
+        fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+        const dlcAccepts = [];
+        initializeResponses.forEach((initializeResponse, i) => {
+            const dlcOffer = dlcOffers[i];
+            const dlcAccept = new messaging_1.DlcAcceptV0();
+            const { fundingPubKey, payoutSPK, payoutSerialId } = initializeResponse;
+            dlcAccept.tempContractId = (0, crypto_1.sha256)(dlcOffers[i].serialize());
+            dlcAccept.acceptCollateralSatoshis = acceptCollaterals[i];
+            dlcAccept.fundingPubKey = fundingPubKey;
+            dlcAccept.payoutSPK = payoutSPK;
+            dlcAccept.payoutSerialId = payoutSerialId;
+            dlcAccept.fundingInputs = fundingInputs;
+            dlcAccept.changeSPK = changeSPK;
+            dlcAccept.changeSerialId = changeSerialId;
+            (0, assert_1.default)(dlcAccept.changeSerialId !== dlcOffer.fundOutputSerialId, 'changeSerialId cannot equal the fundOutputSerialId');
+            (0, assert_1.default)(dlcOffer.payoutSerialId !== dlcAccept.payoutSerialId, 'offer.payoutSerialId cannot equal accept.payoutSerialId');
+            (0, assert_1.default)((() => {
+                const ids = [
+                    dlcOffer.changeSerialId,
+                    dlcAccept.changeSerialId,
+                    dlcOffer.fundOutputSerialId,
+                ];
+                return new Set(ids).size === ids.length;
+            })(), 'offer.changeSerialID, accept.changeSerialId and fundOutputSerialId must be unique');
+            dlcAccept.validate();
+            (0, assert_1.default)((() => {
+                const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSPK, dlcOffer.changeSPK, dlcAccept.fundingInputs, dlcAccept.payoutSPK, dlcAccept.changeSPK, dlcOffer.feeRatePerVb);
+                const funding = fundingInputs.reduce((total, input) => {
+                    return total + input.prevTx.outputs[input.prevTxVout].value.sats;
+                }, BigInt(0));
+                return funding >= acceptCollaterals[i] + finalizer.acceptFees;
+            })(), 'fundingInputs for dlcAccept must be greater than acceptCollateralSatoshis plus acceptFees');
+            dlcAccepts.push(dlcAccept);
+        });
+        const { dlcTransactionsList, nestedMessagesList, } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
+        for (let i = 0; i < dlcAccepts.length; i++) {
+            const dlcOffer = dlcOffers[i];
+            const dlcAccept = dlcAccepts[i];
+            const dlcTransactions = dlcTransactionsList[i];
+            const messagesList = nestedMessagesList[i];
+            const { cetSignatures, refundSignature, } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
+            (0, assert_1.default)(dlcTransactions.type === messaging_1.MessageType.DlcTransactionsV0, 'DlcTransactions must be V0');
+            const _dlcTransactions = dlcTransactions;
+            const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.tempContractId);
+            _dlcTransactions.contractId = contractId;
+            dlcAccepts[i].cetSignatures = cetSignatures;
+            dlcAccepts[i].refundSignature = refundSignature;
+            dlcAccepts[i].negotiationFields = new messaging_1.NegotiationFieldsV0();
+        }
+        return { dlcAccepts, dlcTransactionsList };
+    }
+    /**
+     * Sign Dlc Accept Message
+     * @param _dlcOffer Dlc Offer Message
+     * @param _dlcAccept Dlc Accept Message
+     * @returns {Promise<SignDlcAcceptResponse}
+     */
+    async signDlcAccept(_dlcOffer, _dlcAccept) {
+        const { dlcOffer, dlcAccept } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+        });
+        dlcOffer.validate();
+        dlcAccept.validate();
+        (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
+        const dlcSign = new messaging_1.DlcSignV0();
+        const { dlcTransactions, messagesList } = await this.createDlcTxs(dlcOffer, dlcAccept);
+        await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTransactions, messagesList, true);
+        const { cetSignatures, refundSignature, } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, true);
+        const fundingSignatures = await this.CreateFundingSigs(dlcOffer, dlcAccept, dlcTransactions, true);
+        const dlcTxs = dlcTransactions;
+        const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId);
+        (0, assert_1.default)(Buffer.compare(contractId, (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId)) === 0, 'contractId must be the xor of funding txid, fundingOutputIndex and the tempContractId');
+        dlcTxs.contractId = contractId;
+        dlcSign.contractId = contractId;
+        dlcSign.cetSignatures = cetSignatures;
+        dlcSign.refundSignature = refundSignature;
+        dlcSign.fundingSignatures = fundingSignatures;
+        return { dlcSign, dlcTransactions: dlcTxs };
+    }
+    async batchSignDlcAccept(_dlcOffers, _dlcAccepts) {
+        const dlcOffers = _dlcOffers.map((_dlcOffer) => {
+            const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+            dlcOffer.validate();
+            return dlcOffer;
+        });
+        const dlcAccepts = _dlcAccepts.map((_dlcAccept) => {
+            const { dlcAccept } = (0, Utils_1.checkTypes)({ _dlcAccept });
+            dlcAccept.validate();
+            return dlcAccept;
+        });
+        const { dlcTransactionsList, nestedMessagesList, } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
+        const dlcSigns = [];
+        const fundingSignatures = await this.CreateFundingSigs(dlcOffers[0], dlcAccepts[0], dlcTransactionsList[0], true);
+        for (let i = 0; i < dlcAccepts.length; i++) {
+            const dlcOffer = dlcOffers[i];
+            const dlcAccept = dlcAccepts[i];
+            const dlcTransactions = dlcTransactionsList[i];
+            const messagesList = nestedMessagesList[i];
+            const dlcSign = new messaging_1.DlcSignV0();
+            await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTransactions, messagesList, true);
+            const { cetSignatures, refundSignature, } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, true);
+            const dlcTxs = dlcTransactions;
+            const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId);
+            dlcTxs.contractId = contractId;
+            dlcSign.contractId = contractId;
+            dlcSign.cetSignatures = cetSignatures;
+            dlcSign.refundSignature = refundSignature;
+            dlcSign.fundingSignatures = fundingSignatures;
+            dlcSigns.push(dlcSign);
+        }
+        return { dlcSigns, dlcTransactionsList };
+    }
+    /**
+     * Finalize Dlc Sign
+     * @param _dlcOffer Dlc Offer Message
+     * @param _dlcAccept Dlc Accept Message
+     * @param _dlcSign Dlc Sign Message
+     * @param _dlcTxs Dlc Transactions Message
+     * @returns {Promise<Tx>}
+     */
+    async finalizeDlcSign(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        const payoutResponses = this.GetPayouts(dlcOffer);
+        const { messagesList } = this.FlattenPayouts(payoutResponses);
+        await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, messagesList, false);
+        await this.VerifyFundingSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, false);
+        const fundingSignatures = await this.CreateFundingSigs(dlcOffer, dlcAccept, dlcTxs, false);
+        const fundTx = await this.CreateFundingTx(dlcOffer, dlcAccept, dlcSign, dlcTxs, fundingSignatures);
+        return fundTx;
+    }
+    async batchFinalizeDlcSign(_dlcOffers, _dlcAccepts, _dlcSigns, _dlcTxsList) {
+        const dlcOffers = _dlcOffers.map((_dlcOffer) => {
+            const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+            dlcOffer.validate();
+            return dlcOffer;
+        });
+        const dlcAccepts = _dlcAccepts.map((_dlcAccept) => {
+            const { dlcAccept } = (0, Utils_1.checkTypes)({ _dlcAccept });
+            dlcAccept.validate();
+            return dlcAccept;
+        });
+        const dlcSigns = _dlcSigns.map((_dlcSign) => {
+            const { dlcSign } = (0, Utils_1.checkTypes)({ _dlcSign });
+            return dlcSign;
+        });
+        const dlcTxsList = _dlcTxsList.map((_dlcTxs) => {
+            const { dlcTxs } = (0, Utils_1.checkTypes)({ _dlcTxs });
+            return dlcTxs;
+        });
+        await this.VerifyFundingSigs(dlcOffers[0], dlcAccepts[0], dlcSigns[0], dlcTxsList[0], false);
+        for (let i = 0; i < dlcOffers.length; i++) {
+            const dlcOffer = dlcOffers[i];
+            const dlcAccept = dlcAccepts[i];
+            const dlcSign = dlcSigns[i];
+            const dlcTxs = dlcTxsList[i];
+            const payoutResponses = this.GetPayouts(dlcOffer);
+            const { messagesList } = this.FlattenPayouts(payoutResponses);
+            await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, messagesList, false);
+        }
+        const fundingSignatures = await this.CreateFundingSigs(dlcOffers[0], dlcAccepts[0], dlcTxsList[0], false);
+        const fundTx = await this.CreateFundingTx(dlcOffers[0], dlcAccepts[0], dlcSigns[0], dlcTxsList[0], fundingSignatures);
+        return fundTx;
+    }
+    /**
+     * Execute DLC
+     * @param _dlcOffer Dlc Offer Message
+     * @param _dlcAccept Dlc Accept Message
+     * @param _dlcSign Dlc Sign Message
+     * @param _dlcTxs Dlc Transactions Message
+     * @param oracleAttestation Oracle Attestations TLV (V0)
+     * @param isOfferer Whether party is Dlc Offerer
+     * @returns {Promise<Tx>}
+     */
+    async execute(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, oracleAttestation, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        if (isOfferer === undefined)
+            isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
+        this.ValidateEvent(dlcOffer, oracleAttestation);
+        return this.FindAndSignCet(dlcOffer, dlcAccept, dlcSign, dlcTxs, oracleAttestation, isOfferer);
+    }
+    /**
+     * Refund DLC
+     * @param _dlcOffer Dlc Offer Message
+     * @param _dlcAccept Dlc Accept Message
+     * @param _dlcSign Dlc Sign Message
+     * @param _dlcTxs Dlc Transactions message
+     * @returns {Promise<Tx>}
+     */
+    async refund(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs) {
+        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcSign,
+            _dlcTxs,
+        });
+        const signatures = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+            ? [
+                dlcSign.refundSignature.toString('hex'),
+                dlcAccept.refundSignature.toString('hex'),
+            ]
+            : [
+                dlcAccept.refundSignature.toString('hex'),
+                dlcSign.refundSignature.toString('hex'),
+            ];
+        const addSigsToRefundTxRequest = {
+            refundTxHex: dlcTxs.refundTx.serialize().toString('hex'),
+            signatures,
+            fundTxId: dlcTxs.fundTx.txId.toString(),
+            fundVout: dlcTxs.fundTxVout,
+            localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
+            remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+        };
+        const refundHex = (await this.AddSignaturesToRefundTx(addSigsToRefundTxRequest)).hex;
+        return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(refundHex));
+    }
+    /**
+     * Goal of createDlcClose is for alice (the initiator) to
+     * 1. take dlcoffer, accept, and sign messages. Create a dlcClose message.
+     * 2. Build a close tx, sign.
+     * 3. return dlcClose message (no psbt)
+     */
+    /**
+     * Generate DlcClose messagetype for closing DLC with Mutual Consent
+     * @param _dlcOffer DlcOffer TLV (V0)
+     * @param _dlcAccept DlcAccept TLV (V0)
+     * @param _dlcTxs DlcTransactions TLV (V0)
+     * @param initiatorPayoutSatoshis Amount initiator expects as a payout
+     * @param isOfferer Whether offerer or not
+     * @param _inputs Optionally specified closing inputs
+     * @returns {Promise<DlcClose>}
+     */
+    async createDlcClose(_dlcOffer, _dlcAccept, _dlcTxs, initiatorPayoutSatoshis, isOfferer, _inputs) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        if (isOfferer === undefined)
+            isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
+        const network = await this.getConnectedNetwork();
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+            ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
+            : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+        const p2ms = bitcoinjs_lib_1.payments.p2ms({
+            m: 2,
+            pubkeys: fundingPubKeys,
+            network,
+        });
+        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
+            redeem: p2ms,
+            network,
+        });
+        // Initiate and build PSBT
+        let inputs = _inputs;
+        if (!_inputs) {
+            const tempInputs = await this.GetInputsForAmount([BigInt(20000)], dlcOffer.feeRatePerVb, _inputs);
+            _inputs = tempInputs;
+        }
+        inputs = _inputs.map((input) => {
+            return {
+                ...input,
+                inputSerialId: input.inputSerialId || (0, Utils_1.generateSerialId)(),
+                toUtxo: input.toUtxo,
+            };
+        });
+        const pubkeys = await Promise.all(inputs.map(async (input) => {
+            const address = await this.getMethod('getWalletAddress')(input.address);
+            return Buffer.from(address.publicKey, 'hex');
+        }));
+        const fundingInputSerialId = (0, Utils_1.generateSerialId)();
+        // Make temporary array to hold all inputs and then sort them
+        // this method can be improved later
+        const psbtInputs = [];
+        psbtInputs.push({
+            hash: dlcTxs.fundTx.txId.serialize(),
+            index: dlcTxs.fundTxVout,
+            sequence: 0,
+            witnessUtxo: {
+                script: paymentVariant.output,
+                value: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+            },
+            witnessScript: paymentVariant.redeem.output,
+            inputSerialId: fundingInputSerialId,
+            derivationPath: null,
+        });
+        // add all dlc close inputs
+        inputs.forEach((input, i) => {
+            const paymentVariant = bitcoinjs_lib_1.payments.p2wpkh({ pubkey: pubkeys[i], network });
+            psbtInputs.push({
+                hash: input.txid,
+                index: input.vout,
+                sequence: 0,
+                witnessUtxo: {
+                    script: paymentVariant.output,
+                    value: input.value,
+                },
+                inputSerialId: input.inputSerialId,
+                derivationPath: input.derivationPath,
+            });
+        });
+        // sort all inputs in ascending order by serial ID
+        // The only reason we are doing this is for privacy. If the fundingInput is
+        // always first, it is very obvious. Hence, a serialId is randomly generated
+        // and the inputs are sorted by that instead.
+        const sortedPsbtInputs = psbtInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        // Get index of fundingInput
+        const fundingInputIndex = sortedPsbtInputs.findIndex((input) => input.inputSerialId === fundingInputSerialId);
+        // add to psbt
+        sortedPsbtInputs.forEach((input, i) => psbt.addInput(input));
+        const fundingInputs = await Promise.all(inputs.map(async (input) => {
+            return this.inputToFundingInput(input);
+        }));
+        const finalizer = new core_1.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSPK, dlcAccept.payoutSPK, dlcOffer.feeRatePerVb);
+        const closeInputAmount = BigInt(inputs.reduce((acc, val) => acc + val.value, 0));
+        const offerPayoutValue = isOfferer
+            ? closeInputAmount +
+                initiatorPayoutSatoshis -
+                finalizer.offerInitiatorFees
+            : dlcOffer.contractInfo.totalCollateral - initiatorPayoutSatoshis;
+        const acceptPayoutValue = isOfferer
+            ? dlcOffer.contractInfo.totalCollateral - initiatorPayoutSatoshis
+            : closeInputAmount +
+                initiatorPayoutSatoshis -
+                finalizer.offerInitiatorFees;
+        const offerFirst = dlcOffer.payoutSerialId < dlcAccept.payoutSerialId;
+        psbt.addOutput({
+            value: Number(offerFirst ? offerPayoutValue : acceptPayoutValue),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcOffer.payoutSPK : dlcAccept.payoutSPK, network),
+        });
+        psbt.addOutput({
+            value: Number(offerFirst ? acceptPayoutValue : offerPayoutValue),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcAccept.payoutSPK : dlcOffer.payoutSPK, network),
+        });
+        // Generate keypair to sign inputs
+        const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, isOfferer);
+        // Sign dlc fundinginput
+        psbt.signInput(fundingInputIndex, fundPrivateKeyPair);
+        // Sign dlcclose inputs
+        await Promise.all(sortedPsbtInputs.map(async (input, i) => {
+            if (i === fundingInputIndex)
+                return;
+            // derive keypair
+            const keyPair = await this.getMethod('keyPair')(input.derivationPath);
+            psbt.signInput(i, keyPair);
+        }));
+        // Validate signatures
+        psbt.validateSignaturesOfAllInputs();
+        // Extract close signature from psbt and decode it to only extract r and s values
+        const closeSignature = await bitcoinjs_lib_1.script.signature.decode(psbt.data.inputs[fundingInputIndex].partialSig[0].signature).signature;
+        // Extract funding signatures from psbt
+        const inputSigs = psbt.data.inputs
+            .filter((input) => input !== fundingInputIndex)
+            .map((input) => input.partialSig[0]);
+        // create fundingSignatures
+        const witnessElements = [];
+        for (let i = 0; i < inputSigs.length; i++) {
+            const sigWitness = new messaging_1.ScriptWitnessV0();
+            sigWitness.witness = inputSigs[i].signature;
+            const pubKeyWitness = new messaging_1.ScriptWitnessV0();
+            pubKeyWitness.witness = inputSigs[i].pubkey;
+            witnessElements.push([sigWitness, pubKeyWitness]);
+        }
+        const fundingSignatures = new messaging_1.FundingSignaturesV0();
+        fundingSignatures.witnessElements = witnessElements;
+        // Create DlcClose
+        const dlcClose = new messaging_1.DlcCloseV0();
+        dlcClose.contractId = dlcTxs.contractId;
+        dlcClose.offerPayoutSatoshis = BigInt(psbt.txOutputs[offerFirst ? 0 : 1].value); // You give collateral back to users
+        dlcClose.acceptPayoutSatoshis = BigInt(psbt.txOutputs[offerFirst ? 1 : 0].value); // give collateral back to users
+        dlcClose.fundInputSerialId = fundingInputSerialId; // randomly generated serial id
+        dlcClose.closeSignature = closeSignature;
+        dlcClose.fundingSignatures = fundingSignatures;
+        dlcClose.fundingInputs = fundingInputs;
+        dlcClose.validate();
+        return dlcClose;
+    }
+    /**
+     * Generate multiple DlcClose messagetypes for closing DLC with Mutual Consent
+     * @param _dlcOffer DlcOffer TLV (V0)
+     * @param _dlcAccept DlcAccept TLV (V0)
+     * @param _dlcTxs DlcTransactions TLV (V0)
+     * @param initiatorPayouts Array of amounts initiator expects as payouts
+     * @param isOfferer Whether offerer or not
+     * @param _inputs Optionally specified closing inputs
+     * @returns {Promise<DlcClose[]>}
+     */
+    async createBatchDlcClose(_dlcOffer, _dlcAccept, _dlcTxs, initiatorPayouts, isOfferer, _inputs) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        if (isOfferer === undefined)
+            isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
+        if (_inputs && _inputs.length > 0)
+            throw Error('funding inputs not supported on BatchDlcClose'); // TODO support multiple funding inputs
+        const fundingInputSerialId = (0, Utils_1.generateSerialId)();
+        const fundingInputs = []; // TODO: support multiple funding inputs
+        const finalizer = new core_1.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSPK, dlcAccept.payoutSPK, dlcOffer.feeRatePerVb);
+        // Generate keypair to sign inputs
+        const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, isOfferer);
+        const closeInputAmount = BigInt(0); // TODO support multiple funding inputs
+        const privKey = Buffer.from(fundPrivateKeyPair.privateKey).toString('hex');
+        const rawCloseTxs = await this.CreateCloseRawTxs(dlcOffer, dlcAccept, dlcTxs, closeInputAmount, isOfferer, [], fundingInputs, initiatorPayouts);
+        const sigHashes = await this.CreateSignatureHashes(dlcOffer, dlcAccept, dlcTxs, rawCloseTxs);
+        const signatures = await this.CalculateEcSignatureHashes(sigHashes, privKey);
+        const dlcCloses = [];
+        signatures.forEach((sig, i) => {
+            const payout = initiatorPayouts[i];
+            const payoutMinusOfferFees = finalizer.offerInitiatorFees > payout
+                ? BigInt(0)
+                : payout - finalizer.offerInitiatorFees;
+            const collateralMinusPayout = payout > dlcOffer.contractInfo.totalCollateral
+                ? BigInt(0)
+                : dlcOffer.contractInfo.totalCollateral - payout;
+            const offerPayoutValue = isOfferer
+                ? closeInputAmount + payoutMinusOfferFees
+                : collateralMinusPayout;
+            const acceptPayoutValue = isOfferer
+                ? collateralMinusPayout
+                : closeInputAmount + payoutMinusOfferFees;
+            const fundingSignatures = new messaging_1.FundingSignaturesV0();
+            const dlcClose = new messaging_1.DlcCloseV0();
+            dlcClose.contractId = dlcTxs.contractId;
+            dlcClose.offerPayoutSatoshis = offerPayoutValue;
+            dlcClose.acceptPayoutSatoshis = acceptPayoutValue;
+            dlcClose.fundInputSerialId = fundingInputSerialId;
+            dlcClose.closeSignature = Buffer.from(sig, 'hex');
+            dlcClose.fundingSignatures = fundingSignatures;
+            dlcClose.validate();
+            dlcCloses.push(dlcClose);
+        });
+        return dlcCloses;
+    }
+    async verifyBatchDlcCloseUsingMetadata(dlcCloseMetadata, _dlcCloses, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcTxs } = dlcCloseMetadata.toDlcMessages();
+        await this.verifyBatchDlcClose(dlcOffer, dlcAccept, dlcTxs, _dlcCloses, isOfferer);
+    }
+    /**
+     * Verify multiple DlcClose messagetypes for closing DLC with Mutual Consent
+     * @param _dlcOffer DlcOffer TLV (V0)
+     * @param _dlcAccept DlcAccept TLV (V0)
+     * @param _dlcTxs DlcTransactions TLV (V0)
+     * @param _dlcCloses DlcClose[] TLV (V0)
+     * @param isOfferer Whether offerer or not
+     * @returns {Promise<void>}
+     */
+    async verifyBatchDlcClose(_dlcOffer, _dlcAccept, _dlcTxs, _dlcCloses, isOfferer) {
+        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcTxs,
+        });
+        const dlcCloses = _dlcCloses.map((_dlcClose) => (0, Utils_1.checkTypes)({ _dlcClose }).dlcClose);
+        if (isOfferer === undefined)
+            isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
+        (0, assert_1.default)(dlcCloses.every((dlcClose) => dlcClose.fundingInputs.length === 0), 'funding inputs not supported on verify BatchDlcClose'); // TODO support multiple funding inputs
+        const closeInputAmount = BigInt(0); // TODO support multiple funding inputs
+        const rawCloseTxs = await this.CreateCloseRawTxs(dlcOffer, dlcAccept, dlcTxs, closeInputAmount, isOfferer, dlcCloses);
+        const areSigsValid = await this.VerifySignatures(dlcOffer, dlcAccept, dlcTxs, dlcCloses, rawCloseTxs, isOfferer);
+        (0, assert_1.default)(areSigsValid, 'Signatures invalid in Verify Batch DlcClose');
+    }
+    /**
+     * Goal of finalize Dlc Close is for bob to
+     * 1. take the dlcClose created by alice using createDlcClose,
+     * 2. Build a psbt using Alice's dlcClose message
+     * 3. Sign psbt with bob's privkey
+     * 4. return a tx ready to be broadcast
+     */
+    /**
+     * Finalize Dlc Close
+     * @param _dlcOffer Dlc Offer Message
+     * @param _dlcAccept Dlc Accept Message
+     * @param _dlcClose Dlc Close Message
+     * @param _dlcTxs Dlc Transactions Message
+     * @returns {Promise<Tx>}
+     */
+    async finalizeDlcClose(_dlcOffer, _dlcAccept, _dlcClose, _dlcTxs) {
+        const { dlcOffer, dlcAccept, dlcClose, dlcTxs } = (0, Utils_1.checkTypes)({
+            _dlcOffer,
+            _dlcAccept,
+            _dlcClose,
+            _dlcTxs,
+        });
+        dlcOffer.validate();
+        dlcAccept.validate();
+        dlcClose.validate();
+        const network = await this.getConnectedNetwork();
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+            ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
+            : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+        const p2ms = bitcoinjs_lib_1.payments.p2ms({
+            m: 2,
+            pubkeys: fundingPubKeys,
+            network,
+        });
+        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
+            redeem: p2ms,
+            network,
+        });
+        // Make temporary array to hold all inputs and then sort them
+        // this method can be improved later
+        const psbtInputs = [];
+        psbtInputs.push({
+            hash: dlcTxs.fundTx.txId.serialize(),
+            index: dlcTxs.fundTxVout,
+            sequence: 0,
+            witnessUtxo: {
+                script: paymentVariant.output,
+                value: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+            },
+            witnessScript: paymentVariant.redeem.output,
+            inputSerialId: dlcClose.fundInputSerialId,
+        });
+        // add all dlc close inputs
+        dlcClose.fundingInputs.forEach((input, i) => {
+            psbtInputs.push({
+                hash: input.prevTx.txId.serialize(),
+                index: input.prevTxVout,
+                sequence: 0,
+                witnessUtxo: {
+                    script: input.prevTx.outputs[input.prevTxVout].scriptPubKey
+                        .serialize()
+                        .slice(1),
+                    value: Number(input.prevTx.outputs[input.prevTxVout].value.sats),
+                },
+                inputSerialId: input.inputSerialId,
+            });
+        });
+        // sort all inputs in ascending order by serial ID
+        // The only reason we are doing this is for privacy. If the fundingInput is
+        // always first, it is very obvious. Hence, a serialId is randomly generated
+        // and the inputs are sorted by that instead.
+        const sortedPsbtInputs = psbtInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        // Get index of fundingInput
+        const fundingInputIndex = sortedPsbtInputs.findIndex((input) => input.inputSerialId === dlcClose.fundInputSerialId);
+        const offerFirst = dlcOffer.payoutSerialId < dlcAccept.payoutSerialId;
+        psbt.addOutput({
+            value: Number(offerFirst
+                ? dlcClose.offerPayoutSatoshis
+                : dlcClose.acceptPayoutSatoshis),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcOffer.payoutSPK : dlcAccept.payoutSPK, network),
+        });
+        psbt.addOutput({
+            value: Number(offerFirst
+                ? dlcClose.acceptPayoutSatoshis
+                : dlcClose.offerPayoutSatoshis),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcAccept.payoutSPK : dlcOffer.payoutSPK, network),
+        });
+        // add to psbt
+        sortedPsbtInputs.forEach((input, i) => psbt.addInput(input));
+        const offerer = await this.isOfferer(dlcOffer, dlcAccept);
+        // Generate keypair to sign inputs
+        const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, offerer);
+        // Sign dlc fundinginput
+        psbt.signInput(fundingInputIndex, fundPrivateKeyPair);
+        const partialSig = [
+            {
+                pubkey: offerer ? dlcAccept.fundingPubKey : dlcOffer.fundingPubKey,
+                signature: await bitcoinjs_lib_1.script.signature.encode(dlcClose.closeSignature, 1), // encode using SIGHASH_ALL
+            },
+        ];
+        psbt.updateInput(fundingInputIndex, { partialSig });
+        for (let i = 0; i < psbt.data.inputs.length; ++i) {
+            if (i === fundingInputIndex)
+                continue;
+            if (!psbt.data.inputs[i].partialSig)
+                psbt.data.inputs[i].partialSig = [];
+            const witnessI = dlcClose.fundingSignatures.witnessElements.findIndex((el) => Buffer.compare(bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(el[1].witness)).serialize().slice(1), psbt.data.inputs[i].witnessUtxo.script) === 0);
+            const partialSig = [
+                {
+                    pubkey: dlcClose.fundingSignatures.witnessElements[witnessI][1].witness,
+                    signature: dlcClose.fundingSignatures.witnessElements[witnessI][0].witness,
+                },
+            ];
+            psbt.updateInput(i, { partialSig });
+        }
+        psbt.validateSignaturesOfAllInputs();
+        psbt.finalizeAllInputs();
+        return psbt.extractTransaction().toHex();
+    }
+    async AddSignatureToFundTransaction(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.AddSignatureToFundTransaction(jsonObject);
+    }
+    async CreateCetAdaptorSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateCetAdaptorSignature(jsonObject);
+    }
+    async CreateCetAdaptorSignatures(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateCetAdaptorSignatures(jsonObject);
+    }
+    async AddSignaturesToRefundTx(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.AddSignaturesToRefundTx(jsonObject);
+    }
+    async CreateCet(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateCet(jsonObject);
+    }
+    async CreateDlcTransactions(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateDlcTransactions(jsonObject);
+    }
+    async CreateBatchDlcTransactions(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateBatchDlcTransactions(jsonObject);
+    }
+    async CreateFundTransaction(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateFundTransaction(jsonObject);
+    }
+    async CreateBatchFundTransaction(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateBatchFundTransaction(jsonObject);
+    }
+    async CreateRefundTransaction(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateRefundTransaction(jsonObject);
+    }
+    async GetRawFundTxSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.GetRawFundTxSignature(jsonObject);
+    }
+    async GetRawRefundTxSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.GetRawRefundTxSignature(jsonObject);
+    }
+    async SignCet(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.SignCet(jsonObject);
+    }
+    async VerifyCetAdaptorSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.VerifyCetAdaptorSignature(jsonObject);
+    }
+    async VerifyCetAdaptorSignatures(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.VerifyCetAdaptorSignatures(jsonObject);
+    }
+    async SignFundTransaction(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.SignFundTransaction(jsonObject);
+    }
+    async VerifyFundTxSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.VerifyFundTxSignature(jsonObject);
+    }
+    async VerifyRefundTxSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.VerifyRefundTxSignature(jsonObject);
+    }
+    async fundingInputToInput(_input, findDerivationPath = true) {
+        (0, assert_1.default)(_input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0');
+        const network = await this.getConnectedNetwork();
+        const input = _input;
+        const prevTx = input.prevTx;
+        const prevTxOut = prevTx.outputs[input.prevTxVout];
+        const scriptPubKey = prevTxOut.scriptPubKey.serialize().slice(1);
+        const _address = bitcoinjs_lib_1.address.fromOutputScript(scriptPubKey, network);
+        let derivationPath;
+        if (findDerivationPath) {
+            const inputAddress = await this.client.wallet.findAddress([
+                _address,
+            ]);
+            if (inputAddress) {
+                derivationPath = inputAddress.derivationPath;
+            }
+        }
+        return {
+            txid: prevTx.txId.toString(),
+            vout: input.prevTxVout,
+            address: _address,
+            amount: prevTxOut.value.bitcoin,
+            value: Number(prevTxOut.value.sats),
+            derivationPath,
+            maxWitnessLength: input.maxWitnessLen,
+            redeemScript: input.redeemScript
+                ? input.redeemScript.toString('hex')
+                : '',
+            scriptPubKey: scriptPubKey.toString('hex'),
+            inputSerialId: input.inputSerialId,
+            toUtxo: types_1.Input.prototype.toUtxo,
+        };
+    }
+    async inputToFundingInput(input) {
+        const fundingInput = new messaging_1.FundingInputV0();
+        fundingInput.prevTxVout = input.vout;
+        let txRaw = '';
+        try {
+            txRaw = await this.getMethod('getRawTransactionByHash')(input.txid);
+        }
+        catch (e) {
+            try {
+                txRaw = (await this.getMethod('jsonrpc')('gettransaction', input.txid))
+                    .hex;
+            }
+            catch (e) {
+                throw Error(`Cannot find tx ${input.txid} in inputToFundingInput using getrawtransactionbyhash or gettransaction`);
+            }
+        }
+        const tx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(txRaw));
+        fundingInput.prevTx = tx;
+        fundingInput.sequence = bitcoin_1.Sequence.default();
+        fundingInput.maxWitnessLen = input.maxWitnessLength
+            ? input.maxWitnessLength
+            : 108;
+        fundingInput.redeemScript = input.redeemScript
+            ? Buffer.from(input.redeemScript, 'hex')
+            : Buffer.from('', 'hex');
+        fundingInput.inputSerialId = input.inputSerialId
+            ? input.inputSerialId
+            : (0, Utils_1.generateSerialId)();
+        return fundingInput;
+    }
+    async getConnectedNetwork() {
+        return this._network;
+    }
+}
+exports.default = BitcoinDlcProvider;
+const BurnAddress = 'bcrt1qxcjufgh2jarkp2qkx68azh08w9v5gah8u6es8s';
+//# sourceMappingURL=BitcoinDlcProvider.js.map