@atomicfinance/bitcoin-ddk-provider 4.1.0

package/dist/BitcoinDdkProvider.js

@@ -0,0 +1,2557 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 bitcoin_1 = require("@node-dlc/bitcoin");
+const bufio_1 = require("@node-dlc/bufio");
+const core_1 = require("@node-dlc/core");
+const core_2 = require("@node-dlc/core");
+const crypto_1 = require("@node-dlc/crypto");
+const messaging_1 = require("@node-dlc/messaging");
+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 crypto_2 = __importDefault(require("crypto"));
+const ecpair_1 = require("ecpair");
+const ecc = __importStar(require("tiny-secp256k1"));
+const Utils_1 = require("./utils/Utils");
+const ECPair = (0, ecpair_1.ECPairFactory)(ecc);
+class BitcoinDdkProvider extends provider_1.default {
+    constructor(network, ddkLib) {
+        super();
+        this._network = network;
+        this._ddk = ddkLib;
+    }
+    async DdkLoaded() {
+        while (!this._ddk) {
+            await (0, utils_1.sleep)(10);
+        }
+    }
+    /**
+     * Find private key for DLC funding pubkey by deriving wallet addresses
+     */
+    async findDlcFundingPrivateKey(localFundPubkey, remoteFundPubkey) {
+        const targetPubkeys = [localFundPubkey, remoteFundPubkey];
+        // First check existing wallet addresses
+        const addresses = await this.getMethod('getAddresses')();
+        for (const addressInfo of addresses) {
+            if (addressInfo.derivationPath) {
+                try {
+                    const keyPair = await this.getMethod('keyPair')(addressInfo.derivationPath);
+                    const pubkey = Buffer.from(keyPair.publicKey);
+                    const pubkeyHex = pubkey.toString('hex');
+                    if (targetPubkeys.includes(pubkeyHex)) {
+                        return Buffer.from(keyPair.privateKey).toString('hex');
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        // If not found in existing addresses, do comprehensive search
+        // For DLC splicing, funding pubkeys can be at much higher derivation paths
+        console.log('Searching extensively for DLC funding private key...');
+        for (const isChange of [false, true]) {
+            for (let i = 0; i < 1000; i++) {
+                // Search up to 1000 addresses for DLC keys
+                try {
+                    const address = await this.client.wallet.getAddresses(i, 1, isChange);
+                    if (address && address.length > 0) {
+                        const addressInfo = address[0];
+                        if (addressInfo.derivationPath) {
+                            const keyPair = await this.getMethod('keyPair')(addressInfo.derivationPath);
+                            const pubkey = Buffer.from(keyPair.publicKey);
+                            const pubkeyHex = pubkey.toString('hex');
+                            if (targetPubkeys.includes(pubkeyHex)) {
+                                console.log(`Found DLC funding key at derivation path: ${addressInfo.derivationPath}`);
+                                return Buffer.from(keyPair.privateKey).toString('hex');
+                            }
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        throw new Error(`Could not find private key for DLC funding pubkeys: local=${localFundPubkey}, remote=${remoteFundPubkey}`);
+    }
+    async GetPrivKeysForInputs(inputs) {
+        const privKeys = [];
+        for (let i = 0; i < inputs.length; i++) {
+            const input = inputs[i];
+            if (input.isDlcInput()) {
+                // Handle DLC input - use the dedicated method to find the funding private key
+                const dlcInput = input.dlcInput;
+                const foundPrivKey = await this.findDlcFundingPrivateKey(dlcInput.localFundPubkey, dlcInput.remoteFundPubkey);
+                privKeys.push(foundPrivKey);
+            }
+            else {
+                // Handle regular input
+                let derivationPath = input.derivationPath;
+                if (!derivationPath) {
+                    try {
+                        derivationPath = (await this.getMethod('getWalletAddress')(input.address)).derivationPath;
+                    }
+                    catch (error) {
+                        throw new Error(`Unable to find address ${input.address} in wallet. ` +
+                            `This may happen when using derivation paths outside the normal range. ` +
+                            `Error: ${error.message}`);
+                    }
+                }
+                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';
+        }
+    }
+    /**
+     * Get inputs for amount with explicit supplementation control
+     */
+    async GetInputsForAmountWithMode(amounts, feeRatePerVb, fixedInputs = [], supplementation = types_1.InputSupplementationMode.Required) {
+        if (amounts.length === 0)
+            return [];
+        // For "none" mode, use exactly the provided inputs
+        if (supplementation === types_1.InputSupplementationMode.None) {
+            return fixedInputs;
+        }
+        // For "required" and "optional" modes, attempt supplementation
+        const fixedUtxos = fixedInputs.map((input) => input.toUtxo());
+        try {
+            const inputsForAmount = await this.getMethod('getInputsForDualFunding')(amounts, feeRatePerVb, fixedUtxos);
+            // Convert UTXO objects to Input class instances
+            return inputsForAmount.inputs.map((utxo) => types_1.Input.fromUTXO(utxo));
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+            if (supplementation === types_1.InputSupplementationMode.Required) {
+                throw Error(`Not enough balance GetInputsForAmountWithMode. Error: ${errorMessage}`);
+            }
+            else {
+                // Optional mode: fallback to provided inputs
+                return fixedInputs;
+            }
+        }
+    }
+    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);
+            // Convert UTXO objects to Input class instances
+            inputs = inputsForAmount.inputs.map((utxo) => types_1.Input.fromUTXO(utxo));
+        }
+        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, inputSupplementationMode = types_1.InputSupplementationMode.Required) {
+        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.GetInputsForAmountWithMode([collateral], feeRatePerVb, fixedInputs, inputSupplementationMode);
+        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,
+        };
+    }
+    /**
+     * TODO: Add GetPayoutFromOutcomes
+     *
+     * private GetPayoutsFromOutcomes(
+     *   contractDescriptor: ContractDescriptorV0,
+     *   totalCollateral: bigint,
+     * ): PayoutRequest[] {}
+     */
+    GetPayoutsFromPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        const payoutFunction = contractDescriptor.payoutFunction;
+        if (payoutFunction.payoutFunctionPieces.length === 0)
+            throw Error('PayoutFunction must have at least once PayoutCurvePiece');
+        if (payoutFunction.payoutFunctionPieces.length > 1)
+            throw Error('More than one PayoutCurvePiece not supported');
+        const payoutCurvePiece = payoutFunction.payoutFunctionPieces[0]
+            .payoutCurvePiece;
+        if (payoutCurvePiece.payoutCurvePieceType !== messaging_1.PayoutCurvePieceType.Hyperbola)
+            throw Error('Must be HyperbolaPayoutCurvePiece');
+        if (!payoutCurvePiece.b.eq(messaging_1.F64.ZERO) || !payoutCurvePiece.c.eq(messaging_1.F64.ZERO))
+            throw Error('b and c HyperbolaPayoutCurvePiece values must be 0');
+        // Cast to SingleOracleInfo to access announcement property
+        const singleOracleInfo = oracleInfo;
+        const eventDescriptor = singleOracleInfo.announcement.oracleEvent
+            .eventDescriptor;
+        if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptor)
+            throw Error('Only DigitDecomposition Oracle Events supported');
+        const roundingIntervals = contractDescriptor.roundingIntervals;
+        const cetPayouts = core_2.HyperbolaPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
+        const payoutGroups = [];
+        cetPayouts.forEach((p) => {
+            payoutGroups.push({
+                payout: p.payout,
+                groups: (0, core_2.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
+            });
+        });
+        const rValuesMessagesList = this.GenerateMessages(singleOracleInfo);
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateral, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, true);
+        return { payouts, payoutGroups, messagesList };
+    }
+    GetPayoutsFromPolynomialPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        const payoutFunction = contractDescriptor.payoutFunction;
+        if (payoutFunction.payoutFunctionPieces.length === 0)
+            throw Error('PayoutFunction must have at least once PayoutCurvePiece');
+        for (const piece of payoutFunction.payoutFunctionPieces) {
+            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.DigitDecompositionEventDescriptor)
+            throw Error('Only DigitDecomposition Oracle Events supported');
+        const roundingIntervals = contractDescriptor.roundingIntervals;
+        const cetPayouts = core_2.PolynomialPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
+        const payoutGroups = [];
+        cetPayouts.forEach((p) => {
+            payoutGroups.push({
+                payout: p.payout,
+                groups: (0, core_2.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
+            });
+        });
+        const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateral, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, true);
+        return { payouts, payoutGroups, messagesList };
+    }
+    GetPayouts(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 }]);
+    }
+    GetPayoutsFromEnumeratedDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        const payoutGroups = [];
+        const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+        // For enumerated descriptors, each outcome creates one payout
+        // Each outcome maps to one index in the oracle's possible outcomes
+        contractDescriptor.outcomes.forEach((outcome, index) => {
+            payoutGroups.push({
+                payout: outcome.localPayout,
+                groups: [[index]], // Simple index-based grouping for enum outcomes
+            });
+        });
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateral, totalCollateral - dlcOffer.offerCollateral, true);
+        return { payouts, payoutGroups, messagesList };
+    }
+    GetPayoutsFromContractDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        switch (contractDescriptor.contractDescriptorType) {
+            case messaging_1.ContractDescriptorType.Enumerated: {
+                return this.GetPayoutsFromEnumeratedDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
+            }
+            case messaging_1.ContractDescriptorType.NumericOutcome: {
+                const numericalDescriptor = contractDescriptor;
+                const payoutFunction = numericalDescriptor.payoutFunction;
+                // TODO: add a better check for this
+                const payoutCurvePiece = payoutFunction.payoutFunctionPieces[0].payoutCurvePiece;
+                switch (payoutCurvePiece.payoutCurvePieceType) {
+                    case messaging_1.PayoutCurvePieceType.Hyperbola:
+                        return this.GetPayoutsFromPayoutFunction(dlcOffer, numericalDescriptor, oracleInfo, totalCollateral);
+                    case messaging_1.PayoutCurvePieceType.Polynomial:
+                        return this.GetPayoutsFromPolynomialPayoutFunction(dlcOffer, numericalDescriptor, oracleInfo, totalCollateral);
+                }
+            }
+        }
+    }
+    /**
+     * Converts a @node-dlc/bitcoin Tx to a DDK Transaction
+     * @param tx The @node-dlc/bitcoin transaction
+     * @returns DDK Transaction object
+     */
+    convertTxToDdkTransaction(tx) {
+        return {
+            version: tx.version,
+            lockTime: tx.locktime.value,
+            inputs: tx.inputs.map((input) => ({
+                txid: input.outpoint.txid.toString(),
+                vout: input.outpoint.outputIndex,
+                scriptSig: Buffer.from(''),
+                sequence: input.sequence.value,
+                witness: input.witness.map((witness) => witness.serialize()),
+            })),
+            outputs: tx.outputs.map((output) => ({
+                value: BigInt(output.value.sats),
+                scriptPubkey: output.scriptPubKey.serialize(),
+            })),
+            rawBytes: tx.serialize(),
+        };
+    }
+    async createDlcTxs(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');
+        // Separate regular inputs from DLC inputs (only from offeror side)
+        const localRegularInputs = [];
+        const localDlcInputs = [];
+        for (const fundingInput of dlcOffer.fundingInputs) {
+            if (fundingInput.dlcInput) {
+                // This is a DLC input for splicing
+                // The pubkeys should be from the original DLC to correctly spend its funding output
+                localDlcInputs.push({
+                    fundTx: this.convertTxToDdkTransaction(fundingInput.prevTx),
+                    fundVout: fundingInput.prevTxVout,
+                    localFundPubkey: fundingInput.dlcInput.localFundPubkey,
+                    remoteFundPubkey: fundingInput.dlcInput.remoteFundPubkey,
+                    fundAmount: fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats,
+                    maxWitnessLen: fundingInput.maxWitnessLen,
+                    inputSerialId: fundingInput.inputSerialId,
+                    contractId: fundingInput.dlcInput.contractId,
+                });
+            }
+            else {
+                // Regular input
+                const input = await this.fundingInputToInput(fundingInput, false);
+                localRegularInputs.push(input.toUtxo());
+            }
+        }
+        // Process remote inputs (no DLC inputs from acceptor side)
+        const remoteInputs = await Promise.all(dlcAccept.fundingInputs.map(async (fundingInput) => {
+            const input = await this.fundingInputToInput(fundingInput, false);
+            return input.toUtxo();
+        }));
+        // Calculate input amounts
+        const localInputAmount = localRegularInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        const remoteInputAmount = remoteInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        let payouts = [];
+        let messagesList = [];
+        if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
+            dlcOffer.contractInfo.contractDescriptor.type ===
+                messaging_1.ContractDescriptorType.Enumerated) {
+            for (const outcome of dlcOffer.contractInfo
+                .contractDescriptor.outcomes) {
+                payouts.push({
+                    local: outcome.localPayout,
+                    remote: dlcOffer.offerCollateral +
+                        dlcAccept.acceptCollateral -
+                        outcome.localPayout,
+                });
+                messagesList.push({ messages: [outcome.outcome] });
+            }
+        }
+        else {
+            const payoutResponses = this.GetPayouts(dlcOffer);
+            const { payouts: tempPayouts, messagesList: tempMessagesList } = this.FlattenPayouts(payoutResponses);
+            payouts = tempPayouts;
+            messagesList = tempMessagesList;
+        }
+        const outcomes = payouts.map((payout) => ({
+            offer: BigInt(payout.local),
+            accept: BigInt(payout.remote),
+        }));
+        const localParams = {
+            fundPubkey: Buffer.from(localFundPubkey, 'hex'),
+            changeScriptPubkey: Buffer.from(localChangeScriptPubkey, 'hex'),
+            changeSerialId: BigInt(dlcOffer.changeSerialId),
+            payoutScriptPubkey: Buffer.from(localFinalScriptPubkey, 'hex'),
+            payoutSerialId: BigInt(dlcOffer.payoutSerialId),
+            inputs: localRegularInputs.map((input) => input.toTxInputInfo()),
+            inputAmount: BigInt(localInputAmount),
+            collateral: BigInt(dlcOffer.offerCollateral),
+            dlcInputs: localDlcInputs,
+        };
+        const remoteParams = {
+            fundPubkey: Buffer.from(remoteFundPubkey, 'hex'),
+            changeScriptPubkey: Buffer.from(remoteChangeScriptPubkey, 'hex'),
+            changeSerialId: BigInt(dlcAccept.changeSerialId),
+            payoutScriptPubkey: Buffer.from(remoteFinalScriptPubkey, 'hex'),
+            payoutSerialId: BigInt(dlcAccept.payoutSerialId),
+            inputs: remoteInputs.map((input) => input.toTxInputInfo()),
+            inputAmount: BigInt(remoteInputAmount),
+            collateral: BigInt(dlcAccept.acceptCollateral),
+            dlcInputs: [],
+        };
+        // Determine whether to use regular or spliced DLC transactions
+        const hasDlcInputs = localDlcInputs.length > 0;
+        let dlcTxs;
+        if (hasDlcInputs) {
+            // Use spliced DLC transactions when DLC inputs are present
+            dlcTxs = await this._ddk.createSplicedDlcTransactions(outcomes, localParams, remoteParams, dlcOffer.refundLocktime, BigInt(dlcOffer.feeRatePerVb), 0, dlcOffer.cetLocktime, dlcOffer.fundOutputSerialId);
+        }
+        else {
+            // Use regular DLC transactions when no DLC inputs
+            dlcTxs = this._ddk.createDlcTransactions(outcomes, localParams, remoteParams, dlcOffer.refundLocktime, BigInt(dlcOffer.feeRatePerVb), 0, dlcOffer.cetLocktime, BigInt(dlcOffer.fundOutputSerialId));
+        }
+        const dlcTransactions = new messaging_1.DlcTransactions();
+        dlcTransactions.fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromBuffer(dlcTxs.fund.rawBytes));
+        // Build serial IDs based on actual outputs in the transaction
+        const actualOutputs = dlcTransactions.fundTx.outputs;
+        const serialIds = [];
+        // Always include the funding output serial ID
+        serialIds.push(BigInt(dlcOffer.fundOutputSerialId));
+        // Only include change serial IDs if there are actually change outputs
+        // For exact amount DLCs with no change, there will be only 1 output (the funding output)
+        if (actualOutputs.length > 1) {
+            // Multiple outputs means there are change outputs
+            if (dlcOffer.offerCollateral > 0n) {
+                serialIds.push(BigInt(dlcOffer.changeSerialId));
+            }
+            if (dlcAccept.acceptCollateral > 0n) {
+                serialIds.push(BigInt(dlcAccept.changeSerialId));
+            }
+        }
+        dlcTransactions.fundTxVout = serialIds
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+            .findIndex((i) => BigInt(i) === BigInt(dlcOffer.fundOutputSerialId));
+        // Validate that the calculated fundTxVout is valid
+        if (dlcTransactions.fundTxVout < 0 ||
+            dlcTransactions.fundTxVout >= dlcTransactions.fundTx.outputs.length) {
+            throw new Error(`Invalid fundTxVout calculation: calculated=${dlcTransactions.fundTxVout}, ` +
+                `fundTx.outputs.length=${dlcTransactions.fundTx.outputs.length}, ` +
+                `fundOutputSerialId=${dlcOffer.fundOutputSerialId}, ` +
+                `serialIds=[${serialIds.join(', ')}], ` +
+                `offerCollateral=${dlcOffer.offerCollateral}, ` +
+                `acceptCollateral=${dlcAccept.acceptCollateral}`);
+        }
+        dlcTransactions.cets = dlcTxs.cets.map((cetTx) => bitcoin_1.Tx.decode(bufio_1.StreamReader.fromBuffer(cetTx.rawBytes)));
+        dlcTransactions.refundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromBuffer(dlcTxs.refund.rawBytes));
+        return { dlcTransactions, messagesList };
+    }
+    /**
+     * Computes DLC-spec compliant tagged attestation message digest
+     * This matches what the oracle should sign according to the DLC specification
+     */
+    computeTaggedAttestationMessage(outcome) {
+        // DLC spec: H(H("DLC/oracle/attestation/v0") || H("DLC/oracle/attestation/v0") || H(outcome))
+        const tag = Buffer.from('DLC/oracle/attestation/v0', 'utf8');
+        const tagHash = (0, crypto_1.sha256)(tag);
+        const outcomeBuffer = Buffer.from(outcome, 'utf8');
+        // Compute H(tagHash || tagHash || outcomeHash)
+        const message = (0, crypto_1.sha256)(Buffer.concat([tagHash, tagHash, outcomeBuffer]));
+        return message.toString('hex');
+    }
+    /**
+     * Convert message lists to the format expected by DDK FFI
+     * DDK expects 32-byte message digests (tagged attestation messages)
+     */
+    convertMessagesForDdk(tempMessagesList) {
+        return tempMessagesList.map((message) => [
+            message.messages.map((m) => 
+            // Convert outcome string to tagged attestation message (32-byte hash)
+            Buffer.from(this.computeTaggedAttestationMessage(m), 'hex')),
+        ]);
+    }
+    GenerateEnumMessages(oracleEvent) {
+        const eventDescriptor = oracleEvent.eventDescriptor;
+        // For enum events, each oracle has one nonce and can attest to one of the possible outcomes
+        const messagesList = [];
+        // Pass raw outcome strings to dlcdevkit - it will handle the tagged hashing internally
+        // dlcdevkit expects raw strings and calls tagged_attestation_msg() internally
+        const messages = eventDescriptor.outcomes;
+        messagesList.push({ messages });
+        return messagesList;
+    }
+    convertToJsonSerializable(obj) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (typeof obj === 'bigint') {
+            return Number(obj);
+        }
+        if (Buffer.isBuffer(obj)) {
+            return obj.toString('hex');
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.convertToJsonSerializable(item));
+        }
+        if (typeof obj === 'object') {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.convertToJsonSerializable(value);
+            }
+            return result;
+        }
+        return obj;
+    }
+    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) {
+        // Handle both SingleOracleInfo and MultiOracleInfo using type property instead of instanceof
+        let oracleEvent;
+        if (oracleInfo.type === messaging_1.MessageType.SingleOracleInfo) {
+            const singleOracleInfo = oracleInfo;
+            oracleEvent = singleOracleInfo.announcement.oracleEvent;
+        }
+        else if (oracleInfo.type === messaging_1.MessageType.MultiOracleInfo) {
+            const multiOracleInfo = oracleInfo;
+            // For multi-oracle, use the first announcement for now
+            // TODO: This might need more sophisticated handling for multi-oracle scenarios
+            if (multiOracleInfo.announcements.length === 0) {
+                throw Error('MultiOracleInfo must have at least one announcement');
+            }
+            oracleEvent = multiOracleInfo.announcements[0].oracleEvent;
+        }
+        else {
+            throw Error(`OracleInfo must be SingleOracleInfo or MultiOracleInfo, got type: ${oracleInfo.type}`);
+        }
+        switch (oracleEvent.eventDescriptor.type) {
+            case messaging_1.MessageType.EnumEventDescriptor:
+                return this.GenerateEnumMessages(oracleEvent);
+            case messaging_1.MessageType.DigitDecompositionEventDescriptor:
+                return this.GenerateDigitDecompositionMessages(oracleEvent);
+            default:
+                throw Error('EventDescriptor must be Enum or DigitDecomposition');
+        }
+    }
+    GetContractOraclePairs(_contractInfo) {
+        // Use contractInfoType property instead of instanceof for more reliable type checking
+        if (_contractInfo.contractInfoType === messaging_1.ContractInfoType.Single) {
+            const singleInfo = _contractInfo;
+            return [
+                {
+                    contractDescriptor: singleInfo.contractDescriptor,
+                    oracleInfo: singleInfo.oracleInfo,
+                },
+            ];
+        }
+        else if (_contractInfo.contractInfoType === messaging_1.ContractInfoType.Disjoint) {
+            const disjointInfo = _contractInfo;
+            return disjointInfo.contractOraclePairs;
+        }
+        else {
+            throw Error('ContractInfo must be Single or Disjoint');
+        }
+    }
+    getFundOutputValueSats(dlcTxs) {
+        const fundOutput = dlcTxs.fundTx.outputs[dlcTxs.fundTxVout];
+        if (!fundOutput || !fundOutput.value) {
+            throw new Error(`Invalid fund output at vout ${dlcTxs.fundTxVout}: ` +
+                `outputs.length=${dlcTxs.fundTx.outputs.length}, ` +
+                `output exists=${!!fundOutput}, ` +
+                `output.value exists=${!!(fundOutput && fundOutput.value)}`);
+        }
+        return fundOutput.value.sats;
+    }
+    async CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTxs, messagesList, isOfferer) {
+        const network = await this.getConnectedNetwork();
+        const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
+        // Create the correct P2WSH multisig funding script
+        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,
+        });
+        // We need the redeem script (multisig), not the P2WSH output
+        const fundingSPK = p2ms.output;
+        // For finding the private key, we still need the individual P2WPKH address
+        const individualFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey))
+            .serialize()
+            .slice(1);
+        const fundingAddress = bitcoinjs_lib_1.address.fromOutputScript(individualFundingSPK, 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 sigs = [];
+        if (dlcOffer.contractInfo.contractInfoType === messaging_1.ContractInfoType.Single &&
+            dlcOffer.contractInfo.contractDescriptor.type ===
+                messaging_1.MessageType.ContractDescriptorV0) {
+            for (const { oracleInfo } of contractOraclePairs) {
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                const oracleAnnouncement = oracleInfo
+                    .announcement;
+                const adaptorSigRequestPromises = [];
+                const tempMessagesList = messagesList;
+                const tempCetsHex = cetsHex;
+                const ddkOracleInfo = {
+                    publicKey: oracleAnnouncement.oraclePubkey,
+                    nonces: oracleAnnouncement.oracleEvent.oracleNonces,
+                };
+                adaptorSigRequestPromises.push((async () => {
+                    const cetsForDdk = tempCetsHex.map((cetHex) => this.convertTxToDdkTransaction(bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cetHex))));
+                    const messagesForDdk = this.convertMessagesForDdk(tempMessagesList);
+                    const response = this._ddk.createCetAdaptorSigsFromOracleInfo(cetsForDdk, [ddkOracleInfo], Buffer.from(fundPrivateKey, 'hex'), fundingSPK, this.getFundOutputValueSats(dlcTxs), messagesForDdk);
+                    return response;
+                })());
+                const adaptorPairs = (await Promise.all(adaptorSigRequestPromises)).flat();
+                sigs.push(adaptorPairs.map((adaptorPair) => {
+                    return {
+                        encryptedSig: adaptorPair.signature,
+                        dleqProof: adaptorPair.proof,
+                    };
+                }));
+            }
+        }
+        else {
+            const indices = this.GetIndicesFromPayouts(this.GetPayouts(dlcOffer));
+            for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                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 ddkOracleInfo = {
+                        publicKey: oracleAnnouncement.oraclePubkey,
+                        nonces: oracleAnnouncement.oracleEvent.oracleNonces,
+                    };
+                    const messagesForDdk = this.convertMessagesForDdk(tempMessagesList);
+                    adaptorSigRequestPromises.push((async () => {
+                        const response = this._ddk.createCetAdaptorSigsFromOracleInfo(tempCetsHex.map((cetHex) => this.convertTxToDdkTransaction(bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cetHex)))), [ddkOracleInfo], Buffer.from(fundPrivateKey, 'hex'), fundingSPK, this.getFundOutputValueSats(dlcTxs), messagesForDdk);
+                        return response;
+                    })());
+                }
+                const adaptorPairs = (await Promise.all(adaptorSigRequestPromises)).flat();
+                sigs.push(adaptorPairs.map((adaptorPair) => {
+                    return {
+                        encryptedSig: adaptorPair.signature,
+                        dleqProof: adaptorPair.proof,
+                    };
+                }));
+            }
+        }
+        const refundSignature = this._ddk.getRawFundingTransactionInputSignature(this.convertTxToDdkTransaction(dlcTxs.refundTx), Buffer.from(fundPrivateKey, 'hex'), dlcTxs.fundTx.txId.toString(), dlcTxs.fundTxVout, dlcOffer.contractInfo.totalCollateral);
+        const cetSignatures = new messaging_1.CetAdaptorSignatures();
+        cetSignatures.sigs = sigs.flat();
+        return { cetSignatures, refundSignature };
+    }
+    async VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, messagesList, isOfferer) {
+        const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
+        const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
+        if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
+            dlcOffer.contractInfo.contractDescriptor.type ===
+                messaging_1.MessageType.ContractDescriptorV0) {
+            for (const { oracleInfo } of contractOraclePairs) {
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                const oracleAnnouncement = oracleInfo
+                    .announcement;
+                const oracleEventSigs = isOfferer
+                    ? dlcAccept.cetAdaptorSignatures.sigs
+                    : dlcSign.cetAdaptorSignatures.sigs;
+                const sigsValidity = [];
+                const tempMessagesList = messagesList;
+                const tempSigs = oracleEventSigs;
+                const tempAdaptorPairs = tempSigs.map((sig) => {
+                    return {
+                        signature: sig.encryptedSig,
+                        proof: sig.dleqProof,
+                    };
+                });
+                // Create the correct P2WSH multisig funding script for verification
+                const network = await this.getConnectedNetwork();
+                const verifyFundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+                    ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+                    : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
+                const verifyP2ms = bitcoinjs_lib_1.payments.p2ms({
+                    m: 2,
+                    pubkeys: verifyFundingPubKeys,
+                    network,
+                });
+                // We need the redeem script (multisig), not the P2WSH output
+                const fundingSPK = verifyP2ms.output;
+                const ddkOracleInfo = {
+                    publicKey: oracleAnnouncement.oraclePubkey,
+                    nonces: oracleAnnouncement.oracleEvent.oracleNonces,
+                };
+                const pubkey = isOfferer
+                    ? dlcAccept.fundingPubkey
+                    : dlcOffer.fundingPubkey;
+                const messagesForDdk = this.convertMessagesForDdk(tempMessagesList);
+                sigsValidity.push((async () => {
+                    const response = this._ddk.verifyCetAdaptorSigsFromOracleInfo(tempAdaptorPairs, dlcTxs.cets.map((cet) => this.convertTxToDdkTransaction(cet)), [ddkOracleInfo], pubkey, fundingSPK, this.getFundOutputValueSats(dlcTxs), messagesForDdk);
+                    return response;
+                })());
+                let areSigsValid = (await Promise.all(sigsValidity)).every((b) => b);
+                await this.VerifyRefundSignatureAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer);
+                if (!areSigsValid) {
+                    throw new Error('Invalid signatures received');
+                }
+            }
+        }
+        else {
+            const chunk = 100;
+            const indices = this.GetIndicesFromPayouts(this.GetPayouts(dlcOffer));
+            for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                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.cetAdaptorSignatures.sigs
+                    : dlcSign.cetAdaptorSignatures.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,
+                            proof: sig.dleqProof,
+                        };
+                    });
+                    // Create the correct P2WSH multisig funding script
+                    const network = await this.getConnectedNetwork();
+                    const nonEnumFundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) ===
+                        -1
+                        ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+                        : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
+                    const nonEnumP2ms = bitcoinjs_lib_1.payments.p2ms({
+                        m: 2,
+                        pubkeys: nonEnumFundingPubKeys,
+                        network,
+                    });
+                    // We need the redeem script (multisig), not the P2WSH output
+                    const fundingSPK = nonEnumP2ms.output;
+                    const ddkOracleInfo = {
+                        publicKey: oracleAnnouncement.oraclePubkey,
+                        nonces: oracleAnnouncement.oracleEvent.oracleNonces,
+                    };
+                    const pubkey = isOfferer
+                        ? dlcAccept.fundingPubkey
+                        : dlcOffer.fundingPubkey;
+                    const messagesForDdk = this.convertMessagesForDdk(tempMessagesList);
+                    sigsValidity.push((async () => {
+                        const response = this._ddk.verifyCetAdaptorSigsFromOracleInfo(tempAdaptorPairs, tempCetsHex.map((cet) => this.convertTxToDdkTransaction(bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cet)))), [ddkOracleInfo], pubkey, fundingSPK, this.getFundOutputValueSats(dlcTxs), messagesForDdk);
+                        return response;
+                    })());
+                }
+                let areSigsValid = (await Promise.all(sigsValidity)).every((b) => b);
+                // Verify refund signature using PSBT approach
+                await this.VerifyRefundSignatureAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer);
+                if (!areSigsValid) {
+                    throw new Error('Invalid CET adaptor signatures received');
+                }
+            }
+        }
+    }
+    async CreateFundingSigsAlt(dlcOffer, dlcAccept, dlcTxs, isOfferer) {
+        const transaction = bitcoinjs_lib_1.Transaction.fromBuffer(dlcTxs.fundTx.serialize());
+        const network = await this.getConnectedNetwork();
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        // Combine all funding inputs from both parties
+        const allFundingInputs = [
+            ...dlcOffer.fundingInputs,
+            ...dlcAccept.fundingInputs,
+        ];
+        // Sort by inputSerialId to reconstruct proper transaction order
+        allFundingInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        // Add all inputs to PSBT with proper witnessUtxo
+        for (const fundingInput of allFundingInputs) {
+            const prevOut = fundingInput.prevTx.outputs[fundingInput.prevTxVout];
+            // Use the same pattern as existing code - slice(1) to remove length prefix
+            const witnessUtxo = {
+                script: prevOut.scriptPubKey.serialize().subarray(1),
+                value: Number(prevOut.value.sats),
+            };
+            // Use sequence from the original transaction to ensure consistency
+            const originalInput = transaction.ins.find((input) => input.hash.reverse().toString('hex') ===
+                fundingInput.prevTx.txId.toString() &&
+                input.index === fundingInput.prevTxVout);
+            const sequenceValue = originalInput
+                ? originalInput.sequence
+                : Number(fundingInput.sequence);
+            psbt.addInput({
+                hash: fundingInput.prevTx.txId.toString(),
+                index: fundingInput.prevTxVout,
+                sequence: sequenceValue,
+                witnessUtxo,
+            });
+        }
+        // Add all outputs to PSBT (maintains transaction structure)
+        for (const output of transaction.outs) {
+            psbt.addOutput({
+                address: bitcoinjs_lib_1.address.fromOutputScript(output.script, network),
+                value: output.value,
+            });
+        }
+        // Determine which inputs belong to this party
+        const partyFundingInputs = isOfferer
+            ? dlcOffer.fundingInputs
+            : dlcAccept.fundingInputs;
+        // Convert party's funding inputs to Input objects and get private keys
+        const partyInputs = await Promise.all(partyFundingInputs.map(async (fundingInput) => {
+            return this.fundingInputToInput(fundingInput);
+        }));
+        const inputPrivKeys = await this.GetPrivKeysForInputs(partyInputs);
+        // Create map of this party's inputs for efficient lookup
+        const partyInputMap = new Map();
+        partyInputs.forEach((input, index) => {
+            const key = `${input.txid}:${input.vout}`;
+            partyInputMap.set(key, { input, privKey: inputPrivKeys[index] });
+        });
+        // Initialize witness elements array to match all inputs
+        const witnessElements = [];
+        // Sign only this party's inputs
+        for (let inputIndex = 0; inputIndex < allFundingInputs.length; inputIndex++) {
+            const fundingInput = allFundingInputs[inputIndex];
+            const inputKey = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
+            if (partyInputMap.has(inputKey)) {
+                // This input belongs to this party - sign it
+                const { privKey } = partyInputMap.get(inputKey);
+                const keyPair = ECPair.fromPrivateKey(Buffer.from(privKey, 'hex'));
+                // Check if this is a DLC input (2-of-2 multisig from previous DLC)
+                if (fundingInput.dlcInput) {
+                    // For DLC inputs, we'll need to handle 2-of-2 multisig signing differently
+                    // For now, throw an error as this requires implementing multisig support
+                    throw new Error('DLC input signing not yet implemented in CreateFundingSigsAlt');
+                }
+                else {
+                    // For P2WPKH inputs, use PSBT signing
+                    psbt.signInput(inputIndex, keyPair);
+                    // Extract signature from partial signatures (more reliable than finalization)
+                    const inputData = psbt.data.inputs[inputIndex];
+                    const partialSigs = inputData.partialSig;
+                    if (!partialSigs || partialSigs.length === 0) {
+                        throw new Error(`No signatures found for input ${inputIndex} after signing`);
+                    }
+                    // For P2WPKH, create witness manually: [signature, publicKey]
+                    const sigWitness = new messaging_1.ScriptWitnessV0();
+                    sigWitness.witness = partialSigs[0].signature;
+                    const pubKeyWitness = new messaging_1.ScriptWitnessV0();
+                    pubKeyWitness.witness = keyPair.publicKey;
+                    witnessElements.push([sigWitness, pubKeyWitness]);
+                }
+            }
+            // Note: We don't add anything to witnessElements for other party's inputs
+        }
+        const fundingSignatures = new messaging_1.FundingSignatures();
+        fundingSignatures.witnessElements = witnessElements;
+        return fundingSignatures;
+    }
+    async VerifyFundingSigsAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer) {
+        const network = await this.getConnectedNetwork();
+        const transaction = bitcoinjs_lib_1.Transaction.fromBuffer(dlcTxs.fundTx.serialize());
+        // Get the party whose signatures we're verifying
+        // If we're the offerer, we verify accepter's signatures (from dlcSign)
+        // If we're the accepter, we verify offerer's signatures (from dlcSign)
+        const signingPartyInputs = isOfferer
+            ? dlcAccept.fundingInputs
+            : dlcOffer.fundingInputs;
+        // Combine all inputs to get the correct ordering
+        const allFundingInputs = [
+            ...dlcOffer.fundingInputs,
+            ...dlcAccept.fundingInputs,
+        ];
+        allFundingInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        // Compare transaction IDs
+        const dlcFundTxId = dlcTxs.fundTx.txId.toString();
+        const psbtBuilderTxId = transaction.getId();
+        (0, assert_1.default)(dlcFundTxId === psbtBuilderTxId, 'Transaction IDs do not match');
+        // Create a PSBT for signature verification
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        // Add all inputs (needed for proper sighash calculation)
+        for (const input of allFundingInputs) {
+            const prevOutput = input.prevTx.outputs[input.prevTxVout];
+            psbt.addInput({
+                hash: input.prevTx.txId.toString(),
+                index: input.prevTxVout,
+                sequence: 0,
+                witnessUtxo: {
+                    script: prevOutput.scriptPubKey.serialize().subarray(1),
+                    value: Number(prevOutput.value.sats),
+                },
+            });
+        }
+        // Add all outputs
+        for (const output of transaction.outs) {
+            psbt.addOutput({
+                address: bitcoinjs_lib_1.address.fromOutputScript(output.script, network),
+                value: output.value,
+            });
+        }
+        if (psbt.inputCount !== transaction.ins.length ||
+            psbt.txOutputs.length !== transaction.outs.length) {
+            throw new Error(`PSBT structure doesn't match original transaction`);
+        }
+        // Add the funding signatures to the PSBT as partial signatures
+        let witnessIndex = 0;
+        for (const fundingInput of signingPartyInputs) {
+            // Skip DLC inputs for now (same as CreateFundingSigsAlt)
+            if (fundingInput.dlcInput) {
+                continue;
+            }
+            if (witnessIndex >= dlcSign.fundingSignatures.witnessElements.length) {
+                throw new Error(`Not enough witness elements: expected at least ${witnessIndex + 1}, got ${dlcSign.fundingSignatures.witnessElements.length}`);
+            }
+            const witnessElement = dlcSign.fundingSignatures.witnessElements[witnessIndex];
+            const signature = witnessElement[0].witness;
+            const publicKey = witnessElement[1].witness;
+            // Find this input's index in the sorted transaction
+            const inputIndex = allFundingInputs.findIndex((input) => input.prevTx.txId.toString() ===
+                fundingInput.prevTx.txId.toString() &&
+                input.prevTxVout === fundingInput.prevTxVout);
+            if (inputIndex === -1) {
+                throw new Error(`Input not found in transaction: ${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`);
+            }
+            psbt.updateInput(inputIndex, {
+                partialSig: [{ pubkey: publicKey, signature: signature }],
+            });
+            psbt.validateSignaturesOfInput(inputIndex, (pubkey, msghash, signature) => {
+                return ecc.verify(msghash, pubkey, signature);
+            });
+            witnessIndex++;
+        }
+    }
+    async VerifyRefundSignatureAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer) {
+        const network = await this.getConnectedNetwork();
+        // Get the refund signature we need to verify
+        // If we're the offerer, we verify accepter's refund signature (from dlcAccept)
+        // If we're the accepter, we verify offerer's refund signature (from dlcSign)
+        const refundSignature = isOfferer
+            ? dlcAccept.refundSignature
+            : dlcSign.refundSignature;
+        const signingPubkey = isOfferer
+            ? dlcAccept.fundingPubkey
+            : dlcOffer.fundingPubkey;
+        // Verify refund transaction locktime matches expected
+        if (Number(dlcTxs.refundTx.locktime) !== dlcOffer.refundLocktime) {
+            throw new Error(`Refund transaction locktime ${dlcTxs.refundTx.locktime} does not match expected ${dlcOffer.refundLocktime}`);
+        }
+        // Create a PSBT for the refund transaction verification
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        // Add the funding input
+        const fundingOutput = dlcTxs.fundTx.outputs[dlcTxs.fundTxVout];
+        psbt.addInput({
+            hash: dlcTxs.fundTx.txId.toString(),
+            index: dlcTxs.fundTxVout,
+            sequence: 0,
+            witnessUtxo: {
+                script: fundingOutput.scriptPubKey.serialize().subarray(1), // Remove length prefix
+                value: Number(fundingOutput.value.sats),
+            },
+            witnessScript: this.CreateFundingScript(dlcOffer, dlcAccept), // 2-of-2 multisig script
+        });
+        // Add the refund output
+        const refundOutput = dlcTxs.refundTx.outputs[0];
+        psbt.addOutput({
+            address: bitcoinjs_lib_1.address.fromOutputScript(refundOutput.scriptPubKey.serialize().subarray(1), network),
+            value: Number(refundOutput.value.sats),
+        });
+        // Set the locktime to match the refund transaction
+        psbt.setLocktime(Number(dlcTxs.refundTx.locktime));
+        // Add the refund signature as a partial signature
+        psbt.updateInput(0, {
+            partialSig: [{ pubkey: signingPubkey, signature: refundSignature }],
+        });
+        // Validate the refund signature
+        try {
+            psbt.validateSignaturesOfInput(0, (pubkey, msghash, signature) => {
+                return ecc.verify(msghash, pubkey, signature);
+            });
+        }
+        catch (error) {
+            throw new Error(`Refund signature validation failed for ${isOfferer ? 'accepter' : 'offerer'}: ${error.message}`);
+        }
+    }
+    CreateFundingScript(dlcOffer, dlcAccept) {
+        const network = this.getBitcoinJsNetwork();
+        // Sort funding pubkeys in lexicographical order as per DLC spec
+        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
+        // Create 2-of-2 multisig script
+        const p2ms = bitcoinjs_lib_1.payments.p2ms({
+            m: 2,
+            pubkeys: fundingPubKeys,
+            network,
+        });
+        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
+            redeem: p2ms,
+            network,
+        });
+        return paymentVariant.redeem.output;
+    }
+    async CreateFundingTx(dlcOffer, dlcAccept, dlcSign, dlcTxs, fundingSignatures) {
+        const network = await this.getConnectedNetwork();
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        // Combine and sort all funding inputs by serial ID (same as CreateFundingSigsAlt)
+        const allFundingInputs = [
+            ...dlcOffer.fundingInputs,
+            ...dlcAccept.fundingInputs,
+        ];
+        allFundingInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        // Create a map of input txid:vout to witness elements
+        const witnessMap = new Map();
+        // Map witness elements correctly - CreateFundingSigsAlt only creates witness elements
+        // for the party's own inputs, so we need to map them correctly
+        // For dlcSign (offerer's signatures), map to offerer's inputs only
+        let offererWitnessIndex = 0;
+        dlcOffer.fundingInputs.forEach((fundingInput) => {
+            // Skip DLC inputs for now as in CreateFundingSigsAlt
+            if (fundingInput.dlcInput) {
+                return;
+            }
+            if (offererWitnessIndex < dlcSign.fundingSignatures.witnessElements.length) {
+                const key = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
+                witnessMap.set(key, dlcSign.fundingSignatures.witnessElements[offererWitnessIndex]);
+                offererWitnessIndex++;
+            }
+        });
+        // For fundingSignatures (accepter's signatures), map to accepter's inputs only
+        let accepterWitnessIndex = 0;
+        dlcAccept.fundingInputs.forEach((fundingInput) => {
+            // Skip DLC inputs for now as in CreateFundingSigsAlt
+            if (fundingInput.dlcInput) {
+                return;
+            }
+            if (accepterWitnessIndex < fundingSignatures.witnessElements.length) {
+                const key = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
+                witnessMap.set(key, fundingSignatures.witnessElements[accepterWitnessIndex]);
+                accepterWitnessIndex++;
+            }
+        });
+        // Add all inputs to PSBT with proper sequence values
+        const originalTransaction = bitcoinjs_lib_1.Transaction.fromBuffer(dlcTxs.fundTx.serialize());
+        for (const fundingInput of allFundingInputs) {
+            const prevOut = fundingInput.prevTx.outputs[fundingInput.prevTxVout];
+            // Use same script handling as CreateFundingSigsAlt
+            const witnessUtxo = {
+                script: prevOut.scriptPubKey.serialize().subarray(1),
+                value: Number(prevOut.value.sats),
+            };
+            // Use sequence from the original transaction (same as CreateFundingSigsAlt)
+            const originalInput = originalTransaction.ins.find((input) => input.hash.reverse().toString('hex') ===
+                fundingInput.prevTx.txId.toString() &&
+                input.index === fundingInput.prevTxVout);
+            const sequenceValue = originalInput
+                ? originalInput.sequence
+                : Number(fundingInput.sequence);
+            psbt.addInput({
+                hash: fundingInput.prevTx.txId.toString(),
+                index: fundingInput.prevTxVout,
+                sequence: sequenceValue,
+                witnessUtxo,
+            });
+        }
+        // Add all outputs from the funding transaction
+        for (const output of originalTransaction.outs) {
+            psbt.addOutput({
+                address: bitcoinjs_lib_1.address.fromOutputScript(output.script, network),
+                value: output.value,
+            });
+        }
+        // Finalize inputs with their witness data
+        for (let inputIndex = 0; inputIndex < allFundingInputs.length; inputIndex++) {
+            const fundingInput = allFundingInputs[inputIndex];
+            const inputKey = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
+            const witnessElements = witnessMap.get(inputKey);
+            if (witnessElements && witnessElements.length === 2) {
+                // Skip DLC inputs for now as requested
+                if (fundingInput.dlcInput) {
+                    continue;
+                }
+                // For P2WPKH inputs, finalize the input with witness data
+                const signature = witnessElements[0].witness;
+                const publicKey = witnessElements[1].witness;
+                // Try a simpler approach - let bitcoinjs-lib handle witness construction
+                psbt.finalizeInput(inputIndex, () => ({
+                    finalScriptSig: Buffer.alloc(0),
+                    finalScriptWitness: Buffer.concat([
+                        Buffer.from([0x02]), // witness stack count
+                        Buffer.from([signature.length]),
+                        signature,
+                        Buffer.from([publicKey.length]),
+                        publicKey,
+                    ]),
+                }));
+            }
+        }
+        // Extract the final transaction
+        const finalTx = psbt.extractTransaction();
+        // Convert back to the expected Tx format
+        return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromBuffer(finalTx.toBuffer()));
+    }
+    async FindOutcomeIndexFromPolynomialPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, polynomialPayoutCurvePiece, oracleAttestation, outcome) {
+        const polynomialCurve = core_2.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_2.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_2.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_2.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) {
+            // Fallback to brute force search if payout-based search fails
+            index = 0;
+            groupLength = 0;
+            for (const [, payoutGroup] of payoutGroups.entries()) {
+                groupIndex = payoutGroup.groups.findIndex((group) => {
+                    return group.every((msg, j) => msg === outcomesFormatted[j]);
+                });
+                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 even with brute force search');
+            }
+        }
+        return { index: payoutIndexOffset + index, groupLength };
+    }
+    async FindOutcomeIndex(dlcOffer, oracleAttestation) {
+        const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
+        const contractOraclePairIndex = contractOraclePairs.findIndex(({ oracleInfo }) => {
+            if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo)
+                return false;
+            const singleOracleInfo = oracleInfo;
+            return (singleOracleInfo.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.contractDescriptorType ===
+            messaging_1.ContractDescriptorType.NumericOutcome, 'ContractDescriptor must be NumericOutcome');
+        const contractDescriptor = _contractDescriptor;
+        const _payoutFunction = contractDescriptor.payoutFunction;
+        (0, assert_1.default)(_payoutFunction.type === messaging_1.MessageType.PayoutFunction, 'PayoutFunction must be V0');
+        if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+            throw new Error('Only SingleOracleInfo supported in this context');
+        }
+        const singleOracleInfo = oracleInfo;
+        const eventDescriptor = singleOracleInfo.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.payoutFunctionPieces.sort((a, b) => Number(a.endPoint.eventOutcome) - Number(b.endPoint.eventOutcome));
+        const piece = piecesSorted.find((piece) => outcome < piece.endPoint.eventOutcome);
+        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) {
+        switch (dlcOffer.contractInfo.contractInfoType) {
+            case messaging_1.ContractInfoType.Single: {
+                const contractInfo = dlcOffer.contractInfo;
+                switch (contractInfo.contractDescriptor.contractDescriptorType) {
+                    case messaging_1.ContractDescriptorType.Enumerated: {
+                        const oracleInfo = contractInfo.oracleInfo;
+                        if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                            throw Error('Only SingleOracleInfo supported in this context');
+                        }
+                        const singleOracleInfo = oracleInfo;
+                        if (singleOracleInfo.announcement.oracleEvent.eventId !==
+                            oracleAttestation.eventId)
+                            throw Error('Incorrect Oracle Attestation. Event Id must match.');
+                        break;
+                    }
+                    case messaging_1.ContractDescriptorType.NumericOutcome: {
+                        const oracleInfo = contractInfo.oracleInfo;
+                        if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                            throw Error('Only SingleOracleInfo supported in this context');
+                        }
+                        const singleOracleInfo = oracleInfo;
+                        if (singleOracleInfo.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.ContractInfoType.Disjoint: {
+                const contractInfo = dlcOffer.contractInfo;
+                const attestedOracleEvent = contractInfo.contractOraclePairs.find(({ oracleInfo }) => {
+                    if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo)
+                        return false;
+                    const singleOracleInfo = oracleInfo;
+                    return (singleOracleInfo.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) {
+        if (isOfferer === undefined)
+            isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
+        const fundPrivateKey = await this.GetFundPrivateKey(dlcOffer, dlcAccept, isOfferer);
+        let finalCet;
+        if (dlcOffer.contractInfo.contractInfoType === messaging_1.ContractInfoType.Single &&
+            dlcOffer.contractInfo.contractDescriptor
+                .contractDescriptorType === messaging_1.ContractDescriptorType.Enumerated) {
+            const contractDescriptor = dlcOffer.contractInfo
+                .contractDescriptor;
+            // Handle different contract descriptor outcome formats
+            const attestedOutcome = oracleAttestation.outcomes[0];
+            const outcomeIndex = contractDescriptor.outcomes.findIndex((outcome) => {
+                // Try direct string match first (for DDK2 test: '1', '2', '3')
+                if (outcome.outcome === attestedOutcome) {
+                    return true;
+                }
+                // Try sha256 hash match (for other tests with hashed outcomes)
+                const attestedOutcomeHash = (0, crypto_1.sha256)(Buffer.from(attestedOutcome, 'utf8')).toString('hex');
+                return outcome.outcome === attestedOutcomeHash;
+            });
+            finalCet = this._ddk
+                .signCet(this.convertTxToDdkTransaction(dlcTxs.cets[outcomeIndex]), isOfferer
+                ? dlcAccept.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig
+                : dlcSign.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig, oracleAttestation.signatures, Buffer.from(fundPrivateKey, 'hex'), isOfferer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey, isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey, this.getFundOutputValueSats(dlcTxs))
+                .rawBytes.toString('hex');
+        }
+        else {
+            const { index: outcomeIndex, groupLength } = await this.FindOutcomeIndex(dlcOffer, oracleAttestation);
+            const sliceIndex = -(oracleAttestation.signatures.length - groupLength);
+            const oracleSignatures = sliceIndex === 0
+                ? oracleAttestation.signatures
+                : oracleAttestation.signatures.slice(0, sliceIndex);
+            finalCet = this._ddk
+                .signCet(this.convertTxToDdkTransaction(dlcTxs.cets[outcomeIndex]), isOfferer
+                ? dlcAccept.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig
+                : dlcSign.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig, oracleSignatures, Buffer.from(fundPrivateKey, 'hex'), isOfferer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey, isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey, this.getFundOutputValueSats(dlcTxs))
+                .rawBytes.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 network = await this.getConnectedNetwork();
+        let finalizer;
+        if (_dlcCloses.length === 0) {
+            finalizer = new core_2.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(this.getFundOutputValueSats(dlcTxs)),
+                    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(this.getFundOutputValueSats(dlcTxs)),
+                },
+            };
+            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
+     * @param fixedInputs Optional fixed inputs - can be Input[] for regular inputs or FundingInput[] for DLC inputs
+     * @returns {Promise<DlcOffer>}
+     */
+    async createDlcOffer(contractInfo, offerCollateralSatoshis, feeRatePerVb, cetLocktime, refundLocktime, fixedInputs, inputSupplementationMode) {
+        contractInfo.validate();
+        const network = await this.getConnectedNetwork();
+        const dlcOffer = new messaging_1.DlcOffer();
+        // Generate a random 32-byte temporary contract ID
+        dlcOffer.temporaryContractId = crypto_2.default.randomBytes(32);
+        // Check if we have FundingInput[] (DLC inputs) or Input[] (regular inputs)
+        const hasFundingInputs = fixedInputs && fixedInputs.length > 0 && 'prevTx' in fixedInputs[0]; // FundingInput has prevTx, Input doesn't
+        let fundingPubKey;
+        let payoutSPK;
+        let payoutSerialId;
+        let _fundingInputs;
+        let changeSPK;
+        let changeSerialId;
+        if (hasFundingInputs) {
+            // Handle FundingInput[] directly (for DLC inputs)
+            const fundingInputs = fixedInputs;
+            // Generate addresses directly since we're bypassing Initialize()
+            const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+            payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+            const changeAddress = await this.client.wallet.getUnusedAddress(true);
+            changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+            const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+            fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+            if (fundingAddress.address === payoutAddress.address)
+                throw Error('Address reuse');
+            payoutSerialId = (0, Utils_1.generateSerialId)();
+            changeSerialId = (0, Utils_1.generateSerialId)();
+            _fundingInputs = fundingInputs;
+        }
+        else {
+            // Handle Input[] through existing Initialize() flow
+            const initResult = await this.Initialize(offerCollateralSatoshis, feeRatePerVb, fixedInputs, inputSupplementationMode || types_1.InputSupplementationMode.Required);
+            fundingPubKey = initResult.fundingPubKey;
+            payoutSPK = initResult.payoutSPK;
+            payoutSerialId = initResult.payoutSerialId;
+            _fundingInputs = initResult.fundingInputs;
+            changeSPK = initResult.changeSPK;
+            changeSerialId = initResult.changeSerialId;
+        }
+        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInput, '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.offerCollateral = offerCollateralSatoshis;
+        dlcOffer.fundingInputs = fundingInputs;
+        dlcOffer.changeSpk = changeSPK;
+        dlcOffer.changeSerialId = changeSerialId;
+        dlcOffer.fundOutputSerialId = dlcOffer.fundOutputSerialId =
+            fundOutputSerialId;
+        dlcOffer.feeRatePerVb = feeRatePerVb;
+        dlcOffer.cetLocktime = cetLocktime;
+        dlcOffer.refundLocktime = refundLocktime;
+        if (offerCollateralSatoshis === dlcOffer.contractInfo.totalCollateral) {
+            dlcOffer.markAsSingleFunded();
+        }
+        (0, assert_1.default)((() => {
+            const finalizer = new core_2.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;
+    }
+    /**
+     * Accept DLC Offer (supports single-funded DLCs when accept collateral is 0)
+     * @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.offerCollateral;
+        (0, assert_1.default)(acceptCollateralSatoshis ===
+            dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, 'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis');
+        let fundingPubKey;
+        let payoutSPK;
+        let payoutSerialId;
+        let fundingInputs;
+        let changeSPK;
+        let changeSerialId;
+        if (acceptCollateralSatoshis === BigInt(0)) {
+            // Single-funded DLC: accept side provides no funding
+            const network = await this.getConnectedNetwork();
+            // Still need payout address for receiving DLC outcomes
+            const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+            payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+            // Generate funding pubkey for DLC contract construction
+            const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+            fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+            // Generate change address (even though not used)
+            const changeAddress = await this.client.wallet.getUnusedAddress(true);
+            changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+            if (fundingAddress.address === payoutAddress.address)
+                throw Error('Address reuse');
+            // Generate serial IDs
+            payoutSerialId = (0, Utils_1.generateSerialId)();
+            changeSerialId = (0, Utils_1.generateSerialId)();
+            // No funding inputs for single-funded DLC
+            fundingInputs = [];
+        }
+        else {
+            // Standard DLC: accept side provides funding
+            // Check if we have FundingInput[] (DLC inputs) or Input[] (regular inputs)
+            const hasFundingInputs = fixedInputs && fixedInputs.length > 0 && 'prevTx' in fixedInputs[0]; // FundingInput has prevTx, Input doesn't
+            let initResult;
+            if (hasFundingInputs) {
+                // Handle FundingInput[] directly (for DLC inputs)
+                const fundingInputs = fixedInputs;
+                const network = await this.getConnectedNetwork();
+                // Generate addresses directly since we're bypassing Initialize()
+                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 payoutSerialId = (0, Utils_1.generateSerialId)();
+                const changeSerialId = (0, Utils_1.generateSerialId)();
+                initResult = {
+                    fundingPubKey,
+                    payoutSPK,
+                    payoutSerialId,
+                    fundingInputs,
+                    changeSPK,
+                    changeSerialId,
+                };
+            }
+            else {
+                // Handle Input[] through existing Initialize() flow
+                // Use InputSupplementationMode.None when fixed inputs are provided
+                // to avoid wallet lookup issues with unusual addresses
+                const supplementationMode = fixedInputs && fixedInputs.length > 0
+                    ? types_1.InputSupplementationMode.None
+                    : types_1.InputSupplementationMode.Required;
+                initResult = await this.Initialize(acceptCollateralSatoshis, dlcOffer.feeRatePerVb, fixedInputs, supplementationMode);
+            }
+            fundingPubKey = initResult.fundingPubKey;
+            payoutSPK = initResult.payoutSPK;
+            payoutSerialId = initResult.payoutSerialId;
+            changeSPK = initResult.changeSPK;
+            changeSerialId = initResult.changeSerialId;
+            const _fundingInputs = initResult.fundingInputs;
+            _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInput, 'FundingInput must be V0'));
+            fundingInputs = _fundingInputs.map((input) => input);
+            fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+        }
+        (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubkey, fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
+        const dlcAccept = new messaging_1.DlcAccept();
+        dlcAccept.temporaryContractId = (0, crypto_1.sha256)(dlcOffer.serialize());
+        dlcAccept.acceptCollateral = acceptCollateralSatoshis;
+        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');
+        if (dlcOffer.singleFunded)
+            dlcAccept.markAsSingleFunded();
+        dlcAccept.validate();
+        // Only validate funding requirements if accept side is providing collateral
+        if (acceptCollateralSatoshis > BigInt(0)) {
+            (0, assert_1.default)((() => {
+                const finalizer = new core_2.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);
+        const _dlcTransactions = dlcTransactions;
+        const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.temporaryContractId);
+        _dlcTransactions.contractId = contractId;
+        dlcAccept.cetAdaptorSignatures = cetSignatures;
+        dlcAccept.refundSignature = refundSignature;
+        return { dlcAccept, dlcTransactions: _dlcTransactions };
+    }
+    /**
+     * Sign Dlc Accept Message
+     * @param _dlcOffer Dlc Offer Message
+     * @param _dlcAccept Dlc Accept Message
+     * @returns {Promise<SignDlcAcceptResponse}
+     */
+    async signDlcAccept(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.DlcSign();
+        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.CreateFundingSigsAlt(dlcOffer, dlcAccept, dlcTransactions, true);
+        const dlcTxs = dlcTransactions;
+        const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.temporaryContractId);
+        (0, assert_1.default)(Buffer.compare(contractId, (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.temporaryContractId)) === 0, 'contractId must be the xor of funding txid, fundingOutputIndex and the tempContractId');
+        dlcTxs.contractId = contractId;
+        dlcSign.contractId = contractId;
+        dlcSign.cetAdaptorSignatures = cetSignatures;
+        dlcSign.refundSignature = refundSignature;
+        dlcSign.fundingSignatures = fundingSignatures;
+        return { dlcSign, dlcTransactions: dlcTxs };
+    }
+    /**
+     * 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) {
+        let messagesList = [];
+        if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
+            dlcOffer.contractInfo.contractDescriptor.type ===
+                messaging_1.MessageType.SingleContractInfo) {
+            for (const outcome of dlcOffer.contractInfo
+                .contractDescriptor.outcomes) {
+                messagesList.push({ messages: [outcome.outcome] });
+            }
+        }
+        else {
+            const payoutResponses = this.GetPayouts(dlcOffer);
+            const { messagesList: oracleEventMessagesList } = this.FlattenPayouts(payoutResponses);
+            messagesList = oracleEventMessagesList;
+        }
+        await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, messagesList, false);
+        await this.VerifyFundingSigsAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, false);
+        const fundingSignatures = await this.CreateFundingSigsAlt(dlcOffer, dlcAccept, dlcTxs, false);
+        const fundTx = await this.CreateFundingTx(dlcOffer, dlcAccept, dlcSign, dlcTxs, 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) {
+        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 network = await this.getConnectedNetwork();
+        const psbt = new bitcoinjs_lib_1.Psbt({ network });
+        // Verify refund transaction locktime matches expected
+        if (Number(dlcTxs.refundTx.locktime) !== dlcOffer.refundLocktime) {
+            throw new Error(`Refund transaction locktime ${dlcTxs.refundTx.locktime} does not match expected ${dlcOffer.refundLocktime}`);
+        }
+        // Add the funding input
+        const fundingOutput = dlcTxs.fundTx.outputs[dlcTxs.fundTxVout];
+        psbt.addInput({
+            hash: dlcTxs.fundTx.txId.toString(),
+            index: dlcTxs.fundTxVout,
+            sequence: 0,
+            witnessUtxo: {
+                script: fundingOutput.scriptPubKey.serialize().subarray(1), // Remove length prefix
+                value: Number(fundingOutput.value.sats),
+            },
+            witnessScript: this.CreateFundingScript(dlcOffer, dlcAccept), // 2-of-2 multisig script
+        });
+        // Add the refund output
+        const refundOutput = dlcTxs.refundTx.outputs[0];
+        psbt.addOutput({
+            address: bitcoinjs_lib_1.address.fromOutputScript(refundOutput.scriptPubKey.serialize().subarray(1), network),
+            value: Number(refundOutput.value.sats),
+        });
+        // Set the locktime to match the refund transaction
+        psbt.setLocktime(Number(dlcTxs.refundTx.locktime));
+        // Sort funding pubkeys for consistent signature ordering
+        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
+        // Add both refund signatures as partial signatures
+        psbt.updateInput(0, {
+            partialSig: [
+                { pubkey: fundingPubKeys[0], signature: dlcSign.refundSignature },
+                { pubkey: fundingPubKeys[1], signature: dlcAccept.refundSignature },
+            ],
+        });
+        // Validate all signatures
+        psbt.validateSignaturesOfInput(0, (pubkey, msghash, signature) => {
+            return ecc.verify(msghash, pubkey, signature);
+        });
+        // Finalize the input - this will create the final witness script
+        psbt.finalizeInput(0);
+        // Extract the final transaction
+        const finalTx = psbt.extractTransaction();
+        // Convert to the expected Tx format
+        return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromBuffer(finalTx.toBuffer()));
+    }
+    /**
+     * 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.GetInputsForAmountWithMode([BigInt(20000)], dlcOffer.feeRatePerVb, _inputs || [], types_1.InputSupplementationMode.Required);
+            _inputs = tempInputs;
+        }
+        // Ensure all inputs have derivation paths by fetching from wallet
+        const inputsWithPaths = await Promise.all(_inputs.map(async (input) => {
+            const address = await this.getMethod('getWalletAddress')(input.address);
+            const inputWithPath = new types_1.Input(input.txid, input.vout, input.address, input.amount, input.value, input.derivationPath || address.derivationPath, // Use derivationPath from wallet if not set
+            input.maxWitnessLength, input.redeemScript, input.inputSerialId || (0, Utils_1.generateSerialId)(), input.scriptPubKey, input.label, input.confirmations, input.spendable, input.solvable, input.safe, input.dlcInput);
+            return { input: inputWithPath, address };
+        }));
+        inputs = inputsWithPaths.map((item) => item.input);
+        const pubkeys = inputsWithPaths.map((item) => Buffer.from(item.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(this.getFundOutputValueSats(dlcTxs)),
+            },
+            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) => psbt.addInput(input));
+        const fundingInputs = await Promise.all(inputs.map(async (input) => {
+            return this.inputToFundingInput(input);
+        }));
+        const finalizer = new core_2.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
+            if (!input.derivationPath) {
+                throw new Error(`Missing derivation path for input ${i}`);
+            }
+            const keyPair = await this.getMethod('keyPair')(input.derivationPath);
+            psbt.signInput(i, keyPair);
+        }));
+        // Validate signatures
+        psbt.validateSignaturesOfAllInputs((pubkey, msghash, signature) => {
+            return ecc.verify(msghash, pubkey, signature);
+        });
+        // 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.FundingSignatures();
+        fundingSignatures.witnessElements = witnessElements;
+        // Create DlcClose
+        const dlcClose = new messaging_1.DlcClose();
+        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_2.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.FundingSignatures();
+            const dlcClose = new messaging_1.DlcClose();
+            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(this.getFundOutputValueSats(dlcTxs)),
+            },
+            witnessScript: paymentVariant.redeem.output,
+            inputSerialId: dlcClose.fundInputSerialId,
+        });
+        // add all dlc close inputs
+        dlcClose.fundingInputs.forEach((input) => {
+            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) => 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: 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().subarray(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((pubkey, msghash, signature) => {
+            return ecc.verify(msghash, pubkey, signature);
+        });
+        psbt.finalizeAllInputs();
+        return psbt.extractTransaction().toHex();
+    }
+    async fundingInputToInput(_input, findDerivationPath = true) {
+        (0, assert_1.default)(_input.type === messaging_1.MessageType.FundingInput, '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().subarray(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;
+            }
+        }
+        // Check if this FundingInput has DLC input information to preserve
+        const dlcInputMessage = input.dlcInput;
+        let dlcInputInfo;
+        if (dlcInputMessage) {
+            dlcInputInfo = {
+                localFundPubkey: dlcInputMessage.localFundPubkey.toString('hex'),
+                remoteFundPubkey: dlcInputMessage.remoteFundPubkey.toString('hex'),
+                contractId: dlcInputMessage.contractId.toString('hex'),
+            };
+        }
+        return new types_1.Input(prevTx.txId.toString(), input.prevTxVout, _address, prevTxOut.value.bitcoin, Number(prevTxOut.value.sats), derivationPath, input.maxWitnessLen, input.redeemScript ? input.redeemScript.toString('hex') : '', input.inputSerialId, scriptPubKey.toString('hex'), undefined, // label
+        undefined, // confirmations
+        undefined, // spendable
+        undefined, // solvable
+        undefined, // safe
+        dlcInputInfo);
+    }
+    async inputToFundingInput(input) {
+        const fundingInput = new messaging_1.FundingInput();
+        fundingInput.prevTxVout = input.vout;
+        let txRaw = '';
+        try {
+            txRaw = await this.getMethod('getRawTransactionByHash')(input.txid);
+        }
+        catch {
+            try {
+                txRaw = (await this.getMethod('jsonrpc')('gettransaction', input.txid))
+                    .hex;
+            }
+            catch {
+                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)();
+        // Preserve DLC input information if present
+        if (input.isDlcInput()) {
+            const dlcInputInfo = input.dlcInput;
+            const dlcInput = new messaging_1.DlcInput();
+            dlcInput.localFundPubkey = Buffer.from(dlcInputInfo.localFundPubkey, 'hex');
+            dlcInput.remoteFundPubkey = Buffer.from(dlcInputInfo.remoteFundPubkey, 'hex');
+            dlcInput.contractId = Buffer.alloc(32); // Placeholder contract ID
+            fundingInput.dlcInput = dlcInput;
+        }
+        return fundingInput;
+    }
+    async getConnectedNetwork() {
+        return this._network;
+    }
+    /**
+     * Convert BitcoinNetwork to bitcoinjs-lib network format
+     */
+    getBitcoinJsNetwork() {
+        const network = this._network;
+        if (network.name === 'bitcoin') {
+            return bitcoinjs_lib_1.networks.bitcoin;
+        }
+        else if (network.name === 'testnet') {
+            return bitcoinjs_lib_1.networks.testnet;
+        }
+        else if (network.name === 'regtest') {
+            return bitcoinjs_lib_1.networks.regtest;
+        }
+        else {
+            // Default to mainnet if unknown
+            return bitcoinjs_lib_1.networks.bitcoin;
+        }
+    }
+    /**
+     * Calculate the maximum collateral possible with given inputs
+     * @param inputs Array of Input objects to use for funding
+     * @param feeRatePerVb Fee rate in satoshis per virtual byte
+     * @param contractCount Number of DLC contracts (default: 1)
+     * @returns Maximum collateral amount in satoshis
+     */
+    async calculateMaxCollateral(inputs, feeRatePerVb, contractCount = 1) {
+        if (inputs.length === 0) {
+            return BigInt(0);
+        }
+        try {
+            // Convert Input[] to FundingInput[]
+            const fundingInputs = await Promise.all(inputs.map((input) => this.inputToFundingInput(input)));
+            // Use node-dlc's calculateMaxCollateral function
+            // For single-funded DLC, pass only offerer inputs and fee rate
+            return core_1.BatchDlcTxBuilder.calculateMaxCollateral(fundingInputs, feeRatePerVb, contractCount);
+        }
+        catch (error) {
+            // If calculation fails, return 0 to indicate insufficient funds
+            console.warn('calculateMaxCollateral failed:', error);
+            return BigInt(0);
+        }
+    }
+    /**
+     * Create a funding input with DLC input information for splicing
+     * @param dlcInputInfo DLC input information
+     * @param fundingTxHex Raw transaction hex of the funding transaction
+     */
+    async createDlcFundingInput(dlcInputInfo, fundingTxHex) {
+        const fundingInput = new messaging_1.FundingInput();
+        const tx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(fundingTxHex));
+        fundingInput.prevTx = tx;
+        fundingInput.prevTxVout = dlcInputInfo.fundVout;
+        fundingInput.sequence = bitcoin_1.Sequence.default();
+        fundingInput.maxWitnessLen = dlcInputInfo.maxWitnessLength || 220;
+        fundingInput.redeemScript = Buffer.from('', 'hex'); // Empty for P2WSH
+        fundingInput.inputSerialId = BigInt(dlcInputInfo.inputSerialId || (0, Utils_1.generateSerialId)());
+        // Create the DLC multisig script for address generation
+        const localPubkey = Buffer.from(dlcInputInfo.localFundPubkey, 'hex');
+        const remotePubkey = Buffer.from(dlcInputInfo.remoteFundPubkey, 'hex');
+        // Use the same deterministic ordering as cfd-dlc-js: lexicographic by hex
+        // This matches GetOrderedPubkeys() in cfddlc_transactions.cpp
+        const orderedPubkeys = dlcInputInfo.localFundPubkey < dlcInputInfo.remoteFundPubkey
+            ? [localPubkey, remotePubkey]
+            : [remotePubkey, localPubkey];
+        const network = await this.getConnectedNetwork();
+        // Create 2-of-2 multisig payment using deterministic ordering
+        const p2ms = bitcoinjs_lib_1.payments.p2ms({
+            m: 2,
+            pubkeys: orderedPubkeys,
+            network,
+        });
+        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
+            redeem: p2ms,
+            network,
+        });
+        const multisigAddress = paymentVariant.address;
+        // Verify this matches the actual funding output address
+        const actualFundingOutput = tx.outputs[dlcInputInfo.fundVout];
+        const actualFundingAddress = bitcoinjs_lib_1.address.fromOutputScript(actualFundingOutput.scriptPubKey.serialize().subarray(1), network);
+        if (actualFundingAddress !== multisigAddress) {
+            throw new Error(`DLC funding address mismatch. ` +
+                `Expected: ${actualFundingAddress}, ` +
+                `Constructed: ${multisigAddress}`);
+        }
+        // Add toUtxo method that's expected by GetInputsForAmount
+        fundingInput.toUtxo = () => {
+            return new types_1.Utxo(dlcInputInfo.fundTxid, dlcInputInfo.fundVout, types_1.Amount.FromSatoshis(Number(dlcInputInfo.fundAmount)), multisigAddress, dlcInputInfo.maxWitnessLength || 220, undefined, // DLC inputs don't have derivation paths
+            fundingInput.inputSerialId);
+        };
+        // Create proper DlcInput object for splicing detection and signing
+        const dlcInput = new messaging_1.DlcInput();
+        dlcInput.localFundPubkey = Buffer.from(dlcInputInfo.localFundPubkey, 'hex');
+        dlcInput.remoteFundPubkey = Buffer.from(dlcInputInfo.remoteFundPubkey, 'hex');
+        dlcInput.contractId = Buffer.from(dlcInputInfo.contractId, 'hex');
+        fundingInput.dlcInput = dlcInput;
+        return fundingInput;
+    }
+}
+exports.default = BitcoinDdkProvider;
+//# sourceMappingURL=BitcoinDdkProvider.js.map