@btc-vision/transaction 1.2.1 → 1.2.3

package/build/transaction/TransactionFactory.d.ts

@@ -4,12 +4,14 @@ import { ICustomTransactionParameters } from './builders/CustomScriptTransaction
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
-import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters } from './interfaces/ITransactionParameters.js';
+import { IChallengeSolutionTransactionParameters, IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters } from './interfaces/ITransactionParameters.js';
+import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 export interface DeploymentResult {
     readonly transaction: [string, string];
     readonly contractAddress: string;
     readonly contractPubKey: string;
     readonly p2trAddress: string;
+    readonly preimage: string;
     readonly utxos: UTXO[];
 }
 export interface WrapResult {
@@ -25,18 +27,31 @@ export interface FundingTransactionResponse {
     readonly estimatedFees: bigint;
     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 declare class TransactionFactory {
     createCustomScriptTransaction(interactionParameters: ICustomTransactionParameters): Promise<[string, string, UTXO[]]>;
-    signInteraction(interactionParameters: IInteractionParameters): Promise<[string, string, UTXO[]]>;
+    signInteraction(interactionParameters: IInteractionParameters): Promise<[string, string, UTXO[], string]>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
+    createChallengeSolution(parameters: IChallengeSolutionTransactionParameters): Promise<ChallengeSolution>;
     getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];
+    private _createChallengeSolution;
     private createFundTransaction;
     private writePSBTHeader;
     private getPriorityFee;

package/build/transaction/TransactionFactory.js

@@ -4,6 +4,7 @@ import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
+import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 export class TransactionFactory {
     async createCustomScriptTransaction(interactionParameters) {
         if (!interactionParameters.to) {
@@ -89,6 +90,7 @@ export class TransactionFactory {
             ...interactionParameters,
             utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             randomBytes: preTransaction.getRndBytes(),
+            preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
         };
@@ -98,6 +100,7 @@ export class TransactionFactory {
             signedTransaction.tx.toHex(),
             outTx.toHex(),
             this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
+            preTransaction.getPreimage().toString('hex'),
         ];
     }
     async signDeployment(deploymentParameters) {
@@ -127,6 +130,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: preTransaction.getRndBytes(),
+            preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             optionalOutputs: [],
         };
@@ -148,6 +152,7 @@ export class TransactionFactory {
             contractPubKey: finalTransaction.contractPubKey,
             p2trAddress: finalTransaction.p2trAddress,
             utxos: [refundUTXO],
+            preimage: preTransaction.getPreimage().toString('hex'),
         };
     }
     async createBTCTransfer(parameters) {
@@ -162,6 +167,18 @@ export class TransactionFactory {
             nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
         };
     }
+    async createChallengeSolution(parameters) {
+        if (!parameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+        const resp = await this._createChallengeSolution(parameters);
+        return {
+            estimatedFees: resp.estimatedFees,
+            original: resp.original,
+            tx: resp.tx.toHex(),
+            nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
+        };
+    }
     getAllNewUTXOs(original, tx, to) {
         const outputs = original.getOutputs();
         const utxos = [];
@@ -178,6 +195,21 @@ export class TransactionFactory {
         }
         return utxos;
     }
+    async _createChallengeSolution(parameters) {
+        if (!parameters.to)
+            throw new Error('Field "to" not provided.');
+        const challengeTransaction = new ChallengeSolutionTransaction(parameters);
+        const signedTransaction = 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),
+        };
+    }
     async createFundTransaction(parameters) {
         if (!parameters.to)
             throw new Error('Field "to" not provided.');

package/build/transaction/browser/WalletConnection.d.ts

@@ -0,0 +1,18 @@
+import { Address } from '../../opnet.js';
+import { UnisatSigner } from './extensions/UnisatSigner.js';
+import { XverseSigner } from './extensions/XverseSigner.js';
+export declare enum SupportedWallets {
+    Unisat = "unisat",
+    Xverse = "xverse"
+}
+export declare class WalletConnection {
+    wallet_type: SupportedWallets | null;
+    private unisatSigner;
+    private xverseSigner;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    switchTo(walletType: SupportedWallets): Promise<void>;
+    getAddress(): Address;
+    getSigner(): UnisatSigner | XverseSigner;
+}
+export default WalletConnection;

package/build/transaction/browser/WalletConnection.js

@@ -0,0 +1,95 @@
+import { Address } from '../../opnet.js';
+import { UnisatSigner } from './extensions/UnisatSigner.js';
+import { XverseSigner } from './extensions/XverseSigner.js';
+export var SupportedWallets;
+(function (SupportedWallets) {
+    SupportedWallets["Unisat"] = "unisat";
+    SupportedWallets["Xverse"] = "xverse";
+})(SupportedWallets || (SupportedWallets = {}));
+export class WalletConnection {
+    constructor() {
+        this.wallet_type = null;
+        this.unisatSigner = null;
+        this.xverseSigner = null;
+    }
+    async connect() {
+        if (this.wallet_type) {
+            throw new Error('Wallet already connected');
+        }
+        this.unisatSigner = new UnisatSigner();
+        this.xverseSigner = new XverseSigner();
+        if (window.opnet || window.unisat) {
+            try {
+                await this.unisatSigner.init();
+                this.wallet_type = SupportedWallets.Unisat;
+                return;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(error.message);
+                }
+                throw new Error('Error connecting wallet');
+            }
+        }
+        if (window.BitcoinProvider) {
+            try {
+                await this.xverseSigner.init();
+                this.wallet_type = SupportedWallets.Xverse;
+                return;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(error.message);
+                }
+                throw new Error('Error connecting wallet');
+            }
+        }
+        throw new Error('Wallet not found');
+    }
+    async disconnect() {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+        if (this.wallet_type === SupportedWallets.Unisat) {
+            this.unisatSigner.unisat.disconnect();
+        }
+        else {
+            await this.xverseSigner.BitcoinProvider.request('wallet_disconnect', null);
+        }
+        this.wallet_type = null;
+    }
+    async switchTo(walletType) {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+        if (this.wallet_type === walletType)
+            return;
+        if (walletType === SupportedWallets.Unisat) {
+            await this.unisatSigner.init();
+            this.wallet_type = SupportedWallets.Unisat;
+        }
+        else {
+            await this.xverseSigner.init();
+            this.wallet_type = SupportedWallets.Xverse;
+        }
+    }
+    getAddress() {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+        if (this.wallet_type === SupportedWallets.Unisat) {
+            return Address.fromString(this.unisatSigner.getPublicKey().toString('hex'));
+        }
+        return Address.fromString(this.xverseSigner.getPublicKey().toString('hex'));
+    }
+    getSigner() {
+        if (!this.unisatSigner || !this.xverseSigner) {
+            throw new Error('Wallet not connected');
+        }
+        if (this.wallet_type === SupportedWallets.Unisat) {
+            return this.unisatSigner;
+        }
+        return this.xverseSigner;
+    }
+}
+export default WalletConnection;

package/build/transaction/browser/extensions/UnisatSigner.js

@@ -1,8 +1,8 @@
-import { crypto as bitCrypto, networks, Psbt, script as bitScript, toXOnly, } from '@btc-vision/bitcoin';
+import { crypto as bitCrypto, script as bitScript, networks, Psbt, toXOnly, } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { UnisatNetwork } from '../types/Unisat.js';
-import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 export class UnisatSigner extends CustomKeypair {
     constructor() {
         super();
@@ -67,6 +67,9 @@ export class UnisatSigner extends CustomKeypair {
                 throw new Error(`Invalid network: ${network}`);
         }
         const publicKey = await this.unisat.getPublicKey();
+        if (publicKey === '') {
+            throw new Error('Unlock your wallet first');
+        }
         this._publicKey = Buffer.from(publicKey, 'hex');
         this._p2wpkh = EcKeyPair.getP2WPKHAddress(this, this.network);
         this._p2tr = EcKeyPair.getTaprootAddress(this, this.network);

package/build/transaction/browser/extensions/XverseSigner.js

@@ -1,7 +1,7 @@
 import { networks, Psbt, toXOnly } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
-import { CustomKeypair } from '../BrowserSignerBase.js';
 import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../../signer/SignerUtils.js';
+import { CustomKeypair } from '../BrowserSignerBase.js';
 export class XverseSigner extends CustomKeypair {
     constructor() {
         super();
@@ -50,7 +50,7 @@ export class XverseSigner extends CustomKeypair {
     async init() {
         if (this.isInitialized)
             return;
-        const connectResult = (await this.BitcoinProvider.request('wallet_connect', null));
+        const connectResult = await this.BitcoinProvider.request('wallet_connect', null);
         if ('error' in connectResult)
             throw new Error(connectResult.error.message);
         const payementAddress = connectResult.result.addresses.find((address) => address.purpose === 'payment');
@@ -120,7 +120,7 @@ export class XverseSigner extends CustomKeypair {
         const toSignPsbts = [];
         const options = [];
         for (const psbt of transactions) {
-            const hex = psbt.toHex();
+            const hex = psbt.toBase64();
             toSignPsbts.push(hex);
             const toSignInputs = psbt.data.inputs
                 .map((input, i) => {
@@ -166,10 +166,13 @@ export class XverseSigner extends CustomKeypair {
                 toSignInputs: toSignInputs,
             });
         }
-        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+        const toSignInputs = {
+            [this.p2wpkh]: options[0].toSignInputs?.map((input) => input.index) || [],
+        };
+        const callSign = await this.BitcoinProvider.request('signPsbt', {
             psbt: toSignPsbts[0],
-            signInputs: options[0].toSignInputs,
-        }));
+            signInputs: toSignInputs,
+        });
         if ('error' in callSign)
             throw new Error(callSign.error.message);
         const signedPsbts = Psbt.fromBase64(callSign.result.psbt);
@@ -234,10 +237,13 @@ export class XverseSigner extends CustomKeypair {
             toSignInputs: toSign.flat(),
         };
         const psbt = transaction.toBase64();
-        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+        const toSignInputs = {
+            [this.p2wpkh]: opts.toSignInputs?.map((input) => input.index) || [],
+        };
+        const callSign = await this.BitcoinProvider.request('signPsbt', {
             psbt,
-            signInputs: opts.toSignInputs,
-        }));
+            signInputs: toSignInputs,
+        });
         if ('error' in callSign)
             throw new Error(callSign.error.message);
         return Psbt.fromBase64(callSign.result.psbt);

package/build/transaction/browser/types/Xverse.d.ts

@@ -3,12 +3,11 @@ export declare enum XverseNetwork {
     testnet = "testnet",
     signet = "Signet"
 }
-export type XverseRPCResponse<T = unknown> = {
+type XverseRPCResponse<T = unknown> = {
     id: string;
     jsonrpc: string;
     result: T;
-};
-export type XverseRPCError = {
+} | {
     id: string;
     jsonrpc: string;
     error: {
@@ -16,17 +15,29 @@ export type XverseRPCError = {
         message: string;
     };
 };
-export type XverseRPCGetAccountResponse = XverseRPCResponse<{
+type XverseRPCGetAccountResponse = XverseRPCResponse<{
     addresses: {
         address: string;
         addressType: string;
         publicKey: string;
-        purpose: string;
+        purpose: 'stacks' | 'payment' | 'ordinals';
     }[];
-}> | XverseRPCError;
-export type XverseRPCSignPsbtResponse = XverseRPCResponse<{
+    walletType: string;
+}>;
+type XverseRPCSignPsbtResponse = XverseRPCResponse<{
+    psbt: string;
+}>;
+type XverseRPCGetBalanceResponse = XverseRPCResponse<{
+    confirmed: string;
+    total: string;
+    unconfirmed: string;
+}>;
+export type XVersePSBTInput = {
     psbt: string;
-}> | XverseRPCError;
+    signInputs: {
+        [x: string]: number[];
+    } | undefined;
+};
 interface InscriptionData {
     address: string;
     amount: number;
@@ -66,11 +77,14 @@ interface SignedTransactionResult {
     raw: string;
 }
 export interface Xverse {
-    connect: () => Promise<void>;
+    request(method: string, params: unknown): Promise<XverseRPCResponse>;
+    request(method: 'wallet_connect' | 'wallet_getAccount', params: null): Promise<XverseRPCGetAccountResponse>;
+    request(method: 'wallet_disconnect', params: null): Promise<XverseRPCResponse<null>>;
+    request(method: 'getBalance', params: null): Promise<XverseRPCGetBalanceResponse>;
+    request(method: 'signPsbt', params: XVersePSBTInput): Promise<XverseRPCSignPsbtResponse>;
     addListener: (event: string, callback: (...args: unknown[]) => void) => void;
     createInscription: (data: InscriptionData) => Promise<InscriptionResult>;
     createRepeatInscriptions: (data: RepeatInscriptionsData) => Promise<InscriptionResult[]>;
-    request: (method: string, params: unknown) => Promise<XverseRPCResponse>;
     sendBtcTransaction: (transaction: BtcTransaction) => Promise<TransactionResult>;
     signMessage: (message: string) => Promise<SignedMessageResult>;
     signMultipleTransactions: (transactions: BtcTransaction[]) => Promise<SignedTransactionResult[]>;

package/build/transaction/builders/ChallengeSolutionTransaction.d.ts

@@ -0,0 +1,18 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { IChallengeSolutionTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { Psbt, PsbtInput, Signer } from '@btc-vision/bitcoin';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { ECPairInterface } from 'ecpair';
+export declare class ChallengeSolutionTransaction extends TransactionBuilder<TransactionType.CHALLENGE_SOLUTION> {
+    readonly type: TransactionType.CHALLENGE_SOLUTION;
+    protected amount: bigint;
+    protected readonly challengeSolution: Buffer;
+    constructor(parameters: IChallengeSolutionTransactionParameters);
+    protected buildTransaction(): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean, errored?: boolean): Promise<void>;
+    protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    };
+    protected getSignerKey(): Signer | ECPairInterface;
+}

package/build/transaction/builders/ChallengeSolutionTransaction.js

@@ -0,0 +1,51 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { getFinalScripts, opcodes, script } from '@btc-vision/bitcoin';
+import { TransactionBuilder } from './TransactionBuilder.js';
+export class ChallengeSolutionTransaction extends TransactionBuilder {
+    constructor(parameters) {
+        super(parameters);
+        this.type = TransactionType.CHALLENGE_SOLUTION;
+        this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
+            const inputDecoded = this.inputs[inputIndex];
+            if (isP2SH && inputDecoded && inputDecoded.redeemScript) {
+                const scriptSig = script.compile([this.challengeSolution, inputDecoded.redeemScript]);
+                return {
+                    finalScriptSig: scriptSig,
+                    finalScriptWitness: undefined,
+                };
+            }
+            return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH, false);
+        };
+        this.amount = parameters.amount;
+        this.challengeSolution = parameters.challengeSolution;
+        this.internalInit();
+    }
+    async buildTransaction() {
+        if (!this.to) {
+            throw new Error('Recipient address is required');
+        }
+        this.addInputsFromUTXO();
+        if (this.isPubKeyDestination) {
+            const pubKeyScript = script.compile([
+                Buffer.from(this.to.replace('0x', ''), 'hex'),
+                opcodes.OP_CHECKSIG,
+            ]);
+            this.addOutput({
+                value: Number(this.amount),
+                script: pubKeyScript,
+            });
+        }
+        else {
+            this.addOutput({
+                value: Number(this.amount),
+                address: this.to,
+            });
+        }
+        await this.addRefundOutput(this.amount + this.addOptionalOutputsAndGetAmount());
+    }
+    async signInput(transaction, input, i, signer, reverse = false, errored = false) {
+    }
+    getSignerKey() {
+        return this.signer;
+    }
+}

package/build/transaction/builders/DeploymentTransaction.d.ts

@@ -4,9 +4,12 @@ import { Payment, Psbt } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { Address } from '../../keypair/Address.js';
+import { IMineableReward } from '../mineable/ChallengeGenerator.js';
 export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     static readonly MAXIMUM_CONTRACT_SIZE: number;
     type: TransactionType.DEPLOYMENT;
+    protected readonly preimage: Buffer;
+    protected readonly rewardChallenge: IMineableReward;
     protected readonly _contractAddress: Address;
     protected tapLeafScript: TapLeafScript | null;
     private targetScriptRedeem;
@@ -25,6 +28,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     get contractAddress(): Address;
     get p2trAddress(): string;
     getRndBytes(): Buffer;
+    getPreimage(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;

package/build/transaction/builders/DeploymentTransaction.js

@@ -1,12 +1,13 @@
 import { TransactionType } from '../enums/TransactionType.js';
 import { crypto as bitCrypto, toXOnly, } from '@btc-vision/bitcoin';
-import { TransactionBuilder } from './TransactionBuilder.js';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
 import { DeploymentGenerator } from '../../generators/builders/DeploymentGenerator.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
 import { Address } from '../../keypair/Address.js';
+import { ChallengeGenerator } from '../mineable/ChallengeGenerator.js';
 const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
 export class DeploymentTransaction extends TransactionBuilder {
     constructor(parameters) {
@@ -24,7 +25,6 @@ export class DeploymentTransaction extends TransactionBuilder {
             }
             const scriptSolution = [
                 this.randomBytes,
-                this.internalPubKeyToXOnly(),
                 input.tapScriptSig[0].signature,
                 input.tapScriptSig[1].signature,
             ];
@@ -42,10 +42,12 @@ export class DeploymentTransaction extends TransactionBuilder {
             this.verifyCalldata();
         }
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.preimage = parameters.preimage || BitcoinUtils.getSafeRandomValues(128);
+        this.rewardChallenge = ChallengeGenerator.generateMineableReward(this.preimage, this.network);
         this.contractSeed = this.getContractSeed();
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
         this.deploymentGenerator = new DeploymentGenerator(Buffer.from(this.signer.publicKey), this.contractSignerXOnlyPubKey(), this.network);
-        this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes, this.calldata);
+        this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes, this.preimage, this.calldata);
         this.scriptTree = this.getScriptTree();
         this.internalInit();
         this._contractPubKey = '0x' + this.contractSeed.toString('hex');
@@ -63,6 +65,9 @@ export class DeploymentTransaction extends TransactionBuilder {
     getRndBytes() {
         return this.randomBytes;
     }
+    getPreimage() {
+        return this.preimage;
+    }
     contractSignerXOnlyPubKey() {
         return toXOnly(Buffer.from(this.contractSigner.publicKey));
     }
@@ -89,10 +94,24 @@ export class DeploymentTransaction extends TransactionBuilder {
         };
         this.addInputsFromUTXO();
         const amountSpent = this.getTransactionOPNetFee();
+        let amountToCA;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        }
+        else {
+            amountToCA = amountSpent;
+        }
         this.addOutput({
-            value: Number(amountSpent),
+            value: Number(amountToCA),
             address: this.contractAddress.p2tr(this.network),
         });
+        if (amountToCA === MINIMUM_AMOUNT_CA &&
+            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
+            this.addOutput({
+                value: Number(amountSpent - amountToCA),
+                address: this.rewardChallenge.address,
+            });
+        }
         await this.addRefundOutput(amountSpent + this.addOptionalOutputsAndGetAmount());
     }
     async signInputsWalletBased(transaction) {

package/build/transaction/builders/InteractionTransaction.js

@@ -6,7 +6,7 @@ export class InteractionTransaction extends SharedInteractionTransaction {
         this.type = TransactionType.INTERACTION;
         this.tapLeafScript = null;
         this.contractSecret = this.generateSecret();
-        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret);
+        this.compiledTargetScript = this.calldataGenerator.compile(this.calldata, this.contractSecret, this.preimage);
         this.scriptTree = this.getScriptTree();
         this.internalInit();
     }

package/build/transaction/builders/SharedInteractionTransaction.d.ts

@@ -4,6 +4,7 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import { IMineableReward } from '../mineable/ChallengeGenerator.js';
 export declare abstract class SharedInteractionTransaction<T extends TransactionType> extends TransactionBuilder<T> {
     static readonly MAXIMUM_CALLDATA_SIZE: number;
     readonly randomBytes: Buffer;
@@ -11,6 +12,8 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected leftOverFundsScriptRedeem: Payment | null;
     protected abstract readonly compiledTargetScript: Buffer;
     protected abstract readonly scriptTree: Taptree;
+    protected readonly preimage: Buffer;
+    protected readonly rewardChallenge: IMineableReward;
     protected calldataGenerator: CalldataGenerator;
     protected readonly calldata: Buffer;
     protected abstract readonly contractSecret: Buffer;
@@ -19,6 +22,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected constructor(parameters: SharedInteractionParameters);
     getContractSecret(): Buffer;
     getRndBytes(): Buffer;
+    getPreimage(): Buffer;
     protected generateSecret(): Buffer;
     protected scriptSignerXOnlyPubKey(): Buffer;
     protected generateKeyPairFromSeed(): ECPairInterface;
@@ -32,6 +36,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
         finalScriptWitness: Buffer<ArrayBufferLike>;
     };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
+    private createMineableRewardOutputs;
     private signInputsNonWalletBased;
     private getPubKeys;
     private generateRedeemScripts;