@btc-vision/transaction 1.2.2 → 1.2.4

package/build/transaction/enums/TransactionType.d.ts

@@ -3,8 +3,7 @@ export declare enum TransactionType {
     FUNDING = 1,
     DEPLOYMENT = 2,
     INTERACTION = 3,
-    WBTC_WRAP = 4,
-    WBTC_UNWRAP = 5,
-    MULTI_SIG = 6,
-    CUSTOM_CODE = 7
+    MULTI_SIG = 4,
+    CUSTOM_CODE = 5,
+    CHALLENGE_SOLUTION = 6
 }

package/build/transaction/enums/TransactionType.js

@@ -4,8 +4,7 @@ export var TransactionType;
     TransactionType[TransactionType["FUNDING"] = 1] = "FUNDING";
     TransactionType[TransactionType["DEPLOYMENT"] = 2] = "DEPLOYMENT";
     TransactionType[TransactionType["INTERACTION"] = 3] = "INTERACTION";
-    TransactionType[TransactionType["WBTC_WRAP"] = 4] = "WBTC_WRAP";
-    TransactionType[TransactionType["WBTC_UNWRAP"] = 5] = "WBTC_UNWRAP";
-    TransactionType[TransactionType["MULTI_SIG"] = 6] = "MULTI_SIG";
-    TransactionType[TransactionType["CUSTOM_CODE"] = 7] = "CUSTOM_CODE";
+    TransactionType[TransactionType["MULTI_SIG"] = 4] = "MULTI_SIG";
+    TransactionType[TransactionType["CUSTOM_CODE"] = 5] = "CUSTOM_CODE";
+    TransactionType[TransactionType["CHALLENGE_SOLUTION"] = 6] = "CHALLENGE_SOLUTION";
 })(TransactionType || (TransactionType = {}));

package/build/transaction/interfaces/ITransactionParameters.d.ts

@@ -17,9 +17,14 @@ export interface IFundingTransactionParameters extends ITransactionParameters {
     amount: bigint;
     splitInputsInto?: number;
 }
+export interface IChallengeSolutionTransactionParameters extends ITransactionParameters {
+    amount: bigint;
+    readonly challengeSolution: Buffer;
+}
 export interface SharedInteractionParameters extends ITransactionParameters {
     calldata?: Buffer;
     disableAutoRefund?: boolean;
+    readonly preimage?: Buffer;
     readonly randomBytes?: Buffer;
 }
 export interface IInteractionParameters extends SharedInteractionParameters {
@@ -30,4 +35,5 @@ export interface IDeploymentParameters extends Omit<ITransactionParameters, 'to'
     readonly bytecode: Buffer;
     readonly calldata?: Buffer;
     readonly randomBytes?: Buffer;
+    readonly preimage?: Buffer;
 }

package/build/transaction/mineable/ChallengeGenerator.d.ts

@@ -0,0 +1,9 @@
+import { Network } from '@btc-vision/bitcoin';
+export interface IMineableReward {
+    address: string;
+    p2shOutputScript: Buffer;
+    redeemScript: Buffer;
+}
+export declare class ChallengeGenerator {
+    static generateMineableReward(preimage1: Buffer, network: Network): IMineableReward;
+}

package/build/transaction/mineable/ChallengeGenerator.js

@@ -0,0 +1,28 @@
+import bitcoin from '@btc-vision/bitcoin';
+import { MineableReward } from '../../generators/builders/MineableReward.js';
+export class ChallengeGenerator {
+    static generateMineableReward(preimage1, network) {
+        const mineableReward = new MineableReward(Buffer.alloc(0), network);
+        const redeemScript = mineableReward.compile(preimage1);
+        const p2sh = bitcoin.payments.p2sh({
+            redeem: { output: redeemScript },
+            network,
+        });
+        const outputRedeem = p2sh.redeem?.output;
+        if (!outputRedeem) {
+            throw new Error('Output redeem is required');
+        }
+        if (!p2sh.address) {
+            throw new Error('P2SH address is required');
+        }
+        const p2shOutputScript = p2sh?.redeem?.output;
+        if (!p2shOutputScript) {
+            throw new Error('No redeem output');
+        }
+        return {
+            address: p2sh.address,
+            p2shOutputScript,
+            redeemScript: redeemScript,
+        };
+    }
+}

package/build/transaction/shared/TweakedTransaction.js

@@ -24,7 +24,7 @@ export class TweakedTransaction extends Logger {
         this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
             const inputDecoded = this.inputs[inputIndex];
             if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
-                const signatures = input.partialSig.map((sig) => sig.signature);
+                const signatures = input.partialSig.map((sig) => sig.signature) || [];
                 const scriptSig = script.compile([...signatures, inputDecoded.redeemScript]);
                 return {
                     finalScriptSig: scriptSig,

package/build/utxo/interfaces/IUTXO.d.ts

@@ -1,4 +1,4 @@
-import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
+import { ScriptPubKey } from '@btc-vision/bitcoin-rpc';
 export interface UTXO {
     readonly transactionId: string;
     readonly outputIndex: number;

package/build/verification/TapscriptVerificator.d.ts

@@ -4,6 +4,7 @@ export interface ContractAddressVerificationParams {
     readonly contractSaltPubKey: Buffer;
     readonly originalSalt: Buffer;
     readonly bytecode: Buffer;
+    readonly preimage: Buffer;
     readonly calldata?: Buffer;
     readonly network?: Network;
 }
@@ -12,6 +13,5 @@ export declare class TapscriptVerificator {
     static getContractAddress(params: ContractAddressVerificationParams): string | undefined;
     static verifyControlBlock(params: ContractAddressVerificationParams, controlBlock: Buffer): boolean;
     static getContractSeed(deployerPubKey: Buffer, bytecode: Buffer, saltHash: Buffer): Buffer;
-    static generateContractVirtualAddress(deployerPubKey: Buffer, bytecode: Buffer, saltHash: Buffer, network?: Network): string;
     static generateAddressFromScript(params: ContractAddressVerificationParams, scriptTree: Taptree): string | undefined;
 }

package/build/verification/TapscriptVerificator.js

@@ -1,12 +1,11 @@
 import { crypto as bitCrypto, networks, payments, toXOnly, } from '@btc-vision/bitcoin';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
 import { TransactionBuilder } from '../transaction/builders/TransactionBuilder.js';
-import { Address } from '../keypair/Address.js';
 export class TapscriptVerificator {
     static getContractAddress(params) {
         const network = params.network || networks.bitcoin;
         const scriptBuilder = new DeploymentGenerator(params.deployerPubKey, toXOnly(params.contractSaltPubKey), network);
-        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.calldata);
+        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.preimage, params.calldata);
         const scriptTree = [
             {
                 output: compiledTargetScript,
@@ -22,7 +21,7 @@ export class TapscriptVerificator {
     static verifyControlBlock(params, controlBlock) {
         const network = params.network || networks.bitcoin;
         const scriptBuilder = new DeploymentGenerator(params.deployerPubKey, toXOnly(params.contractSaltPubKey), network);
-        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.calldata);
+        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.preimage, params.calldata);
         const scriptTree = [
             {
                 output: compiledTargetScript,
@@ -55,11 +54,6 @@ export class TapscriptVerificator {
         const buf = Buffer.concat([deployerPubKey, saltHash, sha256OfBytecode]);
         return bitCrypto.hash256(buf);
     }
-    static generateContractVirtualAddress(deployerPubKey, bytecode, saltHash, network = networks.bitcoin) {
-        const virtualAddress = TapscriptVerificator.getContractSeed(deployerPubKey, bytecode, saltHash);
-        const address = new Address(virtualAddress);
-        return address.p2tr(network);
-    }
     static generateAddressFromScript(params, scriptTree) {
         const network = params.network || networks.bitcoin;
         const transactionData = {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.2.2",
+    "version": "1.2.4",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -89,8 +89,8 @@
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
-        "@btc-vision/bitcoin": "^6.3.2",
-        "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
+        "@btc-vision/bitcoin": "^6.3.3",
+        "@btc-vision/bitcoin-rpc": "^1.0.0",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.14.0",
         "@noble/secp256k1": "^2.1.0",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.2.2';
+export const version = '1.2.3';

package/src/generators/Generator.ts

@@ -10,7 +10,7 @@ export abstract class Generator {
     /**
      * The magic number of OPNet
      */
-    public static readonly MAGIC: Buffer = Buffer.from('bsi', 'utf-8');
+    public static readonly MAGIC: Buffer = Buffer.from('op', 'utf-8');
 
     /**
      * The public key of the sender

package/src/generators/builders/CalldataGenerator.ts

@@ -56,18 +56,16 @@ export class CalldataGenerator extends Generator {
      * Compile an interaction bitcoin script
      * @param {Buffer} calldata - The calldata to use
      * @param {Buffer} contractSecret - The contract secret
+     * @param preimage
      * @param {number[]} [features=[]] - The features to use (optional)
-     * @param {Buffer[]} [vaultPublicKeys=[]] - The public keys of the vault (optional)
-     * @param {number} [minimumSignatures=0] - The minimum number of signatures (optional)
      * @returns {Buffer} - The compiled script
      * @throws {Error} - If something goes wrong
      */
     public compile(
         calldata: Buffer,
         contractSecret: Buffer,
+        preimage: Buffer,
         features: Features[] = [],
-        vaultPublicKeys: Buffer[] = [],
-        minimumSignatures: number = 0,
     ): Buffer {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
@@ -78,16 +76,20 @@ export class CalldataGenerator extends Generator {
             this.senderFirstByte,
             opcodes.OP_TOALTSTACK,
 
+            // CHALLENGE PREIMAGE FOR REWARD,
+            preimage,
+            opcodes.OP_TOALTSTACK,
+
             this.xSenderPubKey,
+            opcodes.OP_DUP,
+            opcodes.OP_HASH256,
+            crypto.hash256(this.xSenderPubKey),
+            opcodes.OP_EQUALVERIFY,
             opcodes.OP_CHECKSIGVERIFY,
 
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,
 
-            opcodes.OP_HASH160,
-            crypto.hash160(this.xSenderPubKey),
-            opcodes.OP_EQUALVERIFY,
-
             opcodes.OP_HASH160,
             crypto.hash160(contractSecret),
             opcodes.OP_EQUALVERIFY,
@@ -100,39 +102,6 @@ export class CalldataGenerator extends Generator {
             Generator.MAGIC,
         ];
 
-        // write pub keys, when requested.
-        if (vaultPublicKeys.length > 0) {
-            const pubKeyBuffer = CalldataGenerator.getPubKeyAsBuffer(vaultPublicKeys, this.network);
-            const pubKeyDataChunks: Buffer[][] = this.splitBufferIntoChunks(pubKeyBuffer);
-
-            compiledData = compiledData.concat(
-                ...[
-                    opcodes.OP_0, // provide opnet public keys
-                    ...pubKeyDataChunks,
-                ],
-            );
-
-            if (minimumSignatures) {
-                // verify that the minimum is not greater than 255
-                if (minimumSignatures > 255) {
-                    throw new Error('Minimum signatures cannot exceed 255');
-                }
-
-                // we use a 2 bytes buffer even if we limit to 255 so it does not use an opcode for the number
-                const minSigBuffer = Buffer.alloc(2);
-                minSigBuffer.writeUint16LE(minimumSignatures, 0);
-
-                compiledData = compiledData.concat(
-                    ...[
-                        opcodes.OP_1, // provide minimum signatures
-                        minSigBuffer,
-                    ],
-                );
-            } else {
-                throw new Error('Minimum signatures must be provided');
-            }
-        }
-
         const featureOpcodes = features.map((feature) => FeatureOpCodes[feature]); // Get the opcodes for the features
 
         // Write calldata

package/src/generators/builders/DeploymentGenerator.ts

@@ -14,11 +14,17 @@ export class DeploymentGenerator extends Generator {
      * Compile a bitcoin script representing a contract deployment
      * @param {Buffer} contractBytecode - The contract bytecode
      * @param {Buffer} contractSalt - The contract salt
+     * @param {Buffer} preimage - The preimage for reward
      * @param {Buffer} [calldata] - The calldata to be passed to the contract
      * @returns {Buffer} - The compiled script
      */
-    public compile(contractBytecode: Buffer, contractSalt: Buffer, calldata?: Buffer): Buffer {
-        const asm = this.getAsm(contractBytecode, contractSalt, calldata);
+    public compile(
+        contractBytecode: Buffer,
+        contractSalt: Buffer,
+        preimage: Buffer,
+        calldata?: Buffer,
+    ): Buffer {
+        const asm = this.getAsm(contractBytecode, contractSalt, preimage, calldata);
         const compiled = script.compile(asm);
 
         /**
@@ -35,27 +41,32 @@ export class DeploymentGenerator extends Generator {
     private getAsm(
         contractBytecode: Buffer,
         contractSalt: Buffer,
+        preimage: Buffer,
         calldata?: Buffer,
     ): (number | Buffer)[] {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
         const dataChunks: Buffer[][] = this.splitBufferIntoChunks(contractBytecode);
         const calldataChunks: Buffer[][] = calldata ? this.splitBufferIntoChunks(calldata) : [];
-
+        
         const compiledData = [
             this.senderFirstByte,
             opcodes.OP_TOALTSTACK,
 
+            // CHALLENGE PREIMAGE FOR REWARD,
+            preimage,
+            opcodes.OP_TOALTSTACK,
+
             this.xSenderPubKey,
+            opcodes.OP_DUP,
+            opcodes.OP_HASH256,
+            crypto.hash256(this.xSenderPubKey),
+            opcodes.OP_EQUALVERIFY,
             opcodes.OP_CHECKSIGVERIFY,
 
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,
 
-            opcodes.OP_HASH160,
-            crypto.hash160(this.xSenderPubKey),
-            opcodes.OP_EQUALVERIFY,
-
             opcodes.OP_HASH256,
             crypto.hash256(contractSalt),
             opcodes.OP_EQUALVERIFY,

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -1,4 +1,4 @@
-import { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
+import { crypto, Network, networks, opcodes, script } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -70,6 +70,10 @@ export class LegacyCalldataGenerator extends Generator {
 
         let compiledData = [
             this.senderPubKey,
+            opcodes.OP_DUP,
+            opcodes.OP_HASH256,
+            crypto.hash256(this.senderPubKey),
+            opcodes.OP_EQUALVERIFY,
             opcodes.OP_CHECKSIGVERIFY,
 
             contractSecret,

package/src/generators/builders/MineableReward.ts

@@ -0,0 +1,66 @@
+import { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
+import { Generator } from '../Generator.js';
+
+/**
+ * Class to generate bitcoin script for interaction transactions
+ */
+export class MineableReward extends Generator {
+    constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {
+        super(senderPubKey, Buffer.alloc(0), network);
+    }
+
+    /**
+     * Compile an interaction bitcoin script
+     * @param {Buffer} preimage1 - Preimage 1
+     * @returns {Buffer} - The compiled script
+     * @throws {Error} - If something goes wrong
+     */
+    public compile(preimage1: Buffer): Buffer {
+        let compiledData: (number | Buffer)[];
+
+        if (this.isTestnet()) {
+            compiledData = [
+                preimage1,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_SWAP,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_EQUAL,
+            ];
+        } else {
+            compiledData = [
+                preimage1,
+                opcodes.OP_SWAP,
+                opcodes.OP_2DUP,
+                opcodes.OP_EQUAL,
+                opcodes.OP_NOT,
+                opcodes.OP_VERIFY,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_SWAP,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_EQUAL,
+            ];
+        }
+
+        const asm = compiledData.flat();
+        const compiled = script.compile(asm);
+
+        /** Verify the validity of the script */
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+
+        return compiled;
+    }
+
+    private isTestnet(): boolean {
+        return (
+            this.network.bech32 === networks.testnet.bech32 ||
+            this.network.bech32 === networks.regtest.bech32
+        );
+    }
+}

package/src/opnet.ts

@@ -9,9 +9,12 @@ export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
 export * from './generators/builders/MultiSignGenerator.js';
+export * from './generators/builders/MineableReward.js';
 export * from './generators/Features.js';
 export * from './generators/Generator.js';
 
+export * from './transaction/mineable/ChallengeGenerator.js';
+
 /** Address */
 export * from './generators/AddressGenerator.js';
 export * from './verification/TapscriptVerificator.js';
@@ -44,6 +47,7 @@ export * from './transaction/builders/InteractionTransaction.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
+export * from './transaction/builders/ChallengeSolutionTransaction.js';
 
 /** Utils */
 export * from './utils/BitcoinUtils.js';
@@ -87,6 +91,7 @@ export * from './transaction/browser/extensions/UnisatSigner.js';
 export * from './transaction/browser/extensions/XverseSigner.js';
 export * from './transaction/browser/types/Unisat.js';
 export * from './transaction/browser/types/Xverse.js';
+export * from './transaction/browser/WalletConnection.js';
 
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';

package/src/transaction/TransactionFactory.ts

@@ -11,12 +11,14 @@ import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
 import {
+    IChallengeSolutionTransactionParameters,
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
     ITransactionParameters,
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
+import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -25,6 +27,8 @@ export interface DeploymentResult {
     readonly contractPubKey: string;
     readonly p2trAddress: string;
 
+    readonly preimage: string;
+
     readonly utxos: UTXO[];
 }
 
@@ -43,13 +47,27 @@ export interface FundingTransactionResponse {
     readonly nextUTXOs: UTXO[];
 }
 
-export interface BitcoinTransferResponse {
+export interface ChallengeSolutionResponse {
+    readonly tx: Transaction;
+    readonly original: ChallengeSolutionTransaction;
+    readonly estimatedFees: bigint;
+    readonly nextUTXOs: UTXO[];
+}
+
+export interface BitcoinTransferBase {
     readonly tx: string;
-    readonly original: FundingTransaction;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
 }
 
+export interface ChallengeSolution extends BitcoinTransferBase {
+    readonly original: ChallengeSolutionTransaction;
+}
+
+export interface BitcoinTransferResponse extends BitcoinTransferBase {
+    readonly original: FundingTransaction;
+}
+
 export class TransactionFactory {
     /**
      * @description Generate a transaction with a custom script.
@@ -127,7 +145,7 @@ export class TransactionFactory {
      */
     public async signInteraction(
         interactionParameters: IInteractionParameters,
-    ): Promise<[string, string, UTXO[]]> {
+    ): Promise<[string, string, UTXO[], string]> {
         if (!interactionParameters.to) {
             throw new Error('Field "to" not provided.');
         }
@@ -185,6 +203,7 @@ export class TransactionFactory {
             ...interactionParameters,
             utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
             randomBytes: preTransaction.getRndBytes(),
+            preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
         };
@@ -197,6 +216,7 @@ export class TransactionFactory {
             signedTransaction.tx.toHex(),
             outTx.toHex(),
             this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1), // always 1
+            preTransaction.getPreimage().toString('hex'),
         ];
     }
 
@@ -244,6 +264,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: preTransaction.getRndBytes(),
+            preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             optionalOutputs: [],
         };
@@ -270,6 +291,7 @@ export class TransactionFactory {
             contractPubKey: finalTransaction.contractPubKey,
             p2trAddress: finalTransaction.p2trAddress,
             utxos: [refundUTXO],
+            preimage: preTransaction.getPreimage().toString('hex'),
         };
     }
 
@@ -286,7 +308,27 @@ export class TransactionFactory {
         }
 
         const resp = await this.createFundTransaction(parameters);
+        return {
+            estimatedFees: resp.estimatedFees,
+            original: resp.original,
+            tx: resp.tx.toHex(),
+            nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
+        };
+    }
 
+    /**
+     * @description Creates a challenge solution transaction.
+     * @param {IChallengeSolutionTransactionParameters} parameters - The challenge solution transaction parameters
+     * @returns {Promise<ChallengeSolution>} - The signed transaction
+     */
+    public async createChallengeSolution(
+        parameters: IChallengeSolutionTransactionParameters,
+    ): Promise<ChallengeSolution> {
+        if (!parameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+
+        const resp = await this._createChallengeSolution(parameters);
         return {
             estimatedFees: resp.estimatedFees,
             original: resp.original,
@@ -323,6 +365,27 @@ export class TransactionFactory {
         return utxos;
     }
 
+    private async _createChallengeSolution(
+        parameters: IChallengeSolutionTransactionParameters,
+    ): Promise<ChallengeSolutionResponse> {
+        if (!parameters.to) throw new Error('Field "to" not provided.');
+
+        const challengeTransaction: ChallengeSolutionTransaction = new ChallengeSolutionTransaction(
+            parameters,
+        );
+        const signedTransaction: Transaction = await challengeTransaction.signTransaction();
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        return {
+            tx: signedTransaction,
+            original: challengeTransaction,
+            estimatedFees: challengeTransaction.estimatedFees,
+            nextUTXOs: this.getUTXOAsTransaction(signedTransaction, parameters.to, 0),
+        };
+    }
+
     private async createFundTransaction(
         parameters: IFundingTransactionParameters,
     ): Promise<FundingTransactionResponse> {