@btc-vision/transaction 1.2.2 → 1.2.4

package/src/transaction/browser/WalletConnection.ts

@@ -0,0 +1,110 @@
+import { Address } from '../../opnet.js';
+import { UnisatSigner } from './extensions/UnisatSigner.js';
+import { XverseSigner } from './extensions/XverseSigner.js';
+
+export enum SupportedWallets {
+    Unisat = 'unisat',
+    Xverse = 'xverse',
+}
+
+export class WalletConnection {
+    public wallet_type: SupportedWallets | null = null;
+
+    private unisatSigner: UnisatSigner | null = null; // OP_WALLET and Unisat wallet
+    private xverseSigner: XverseSigner | null = null;
+
+    public async connect(): Promise<void> {
+        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: unknown) {
+                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: unknown) {
+                if (error instanceof Error) {
+                    throw new Error(error.message);
+                }
+
+                throw new Error('Error connecting wallet');
+            }
+        }
+
+        throw new Error('Wallet not found');
+    }
+
+    public async disconnect(): Promise<void> {
+        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;
+    }
+
+    public async switchTo(walletType: SupportedWallets): Promise<void> {
+        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;
+        }
+    }
+
+    public getAddress(): Address {
+        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'));
+    }
+
+    public getSigner(): UnisatSigner | XverseSigner {
+        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/src/transaction/browser/extensions/UnisatSigner.ts

@@ -1,18 +1,18 @@
 import {
     crypto as bitCrypto,
+    script as bitScript,
     Network,
     networks,
     Psbt,
-    script as bitScript,
     TapScriptSig,
     toXOnly,
 } from '@btc-vision/bitcoin';
+import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
+import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, Unisat, UnisatNetwork } from '../types/Unisat.js';
-import { PartialSig } from 'bip174/src/lib/interfaces.js';
-import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 
 declare global {
     interface Window {
@@ -112,6 +112,10 @@ export class UnisatSigner extends CustomKeypair {
         }
 
         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 as unknown as ECPairInterface, this.network);

package/src/transaction/browser/extensions/XverseSigner.ts

@@ -2,14 +2,14 @@ import { Network, networks, Psbt, TapScriptSig, toXOnly } from '@btc-vision/bitc
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
-import { CustomKeypair } from '../BrowserSignerBase.js';
-import { PsbtSignatureOptions } from '../types/Unisat.js';
-import { Xverse, XverseRPCGetAccountResponse, XverseRPCSignPsbtResponse } from '../types/Xverse.js';
 import {
     canSignNonTaprootInput,
     isTaprootInput,
     pubkeyInScript,
 } from '../../../signer/SignerUtils.js';
+import { CustomKeypair } from '../BrowserSignerBase.js';
+import { PsbtSignatureOptions } from '../types/Unisat.js';
+import { Xverse } from '../types/Xverse.js';
 
 declare global {
     interface Window {
@@ -90,10 +90,7 @@ export class XverseSigner extends CustomKeypair {
     public async init(): Promise<void> {
         if (this.isInitialized) return;
 
-        const connectResult = (await this.BitcoinProvider.request(
-            'wallet_connect',
-            null,
-        )) as XverseRPCGetAccountResponse;
+        const connectResult = await this.BitcoinProvider.request('wallet_connect', null);
 
         if ('error' in connectResult) throw new Error(connectResult.error.message);
 
@@ -193,7 +190,7 @@ export class XverseSigner extends CustomKeypair {
         const options: PsbtSignatureOptions[] = [];
 
         for (const psbt of transactions) {
-            const hex = psbt.toHex();
+            const hex = psbt.toBase64();
             toSignPsbts.push(hex);
 
             const toSignInputs = psbt.data.inputs
@@ -245,23 +242,20 @@ export class XverseSigner extends CustomKeypair {
             });
         }
 
-        // const signed = await this.unisat.signPsbt(toSignPsbts[0], options[0]);
+        const toSignInputs: {
+            [x: string]: number[];
+        } = {
+            [this.p2wpkh]: options[0].toSignInputs?.map((input) => input.index) || [],
+        };
 
-        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+        const callSign = await this.BitcoinProvider.request('signPsbt', {
             psbt: toSignPsbts[0],
-            signInputs: options[0].toSignInputs,
-        })) as XverseRPCSignPsbtResponse;
+            signInputs: toSignInputs,
+        });
 
         if ('error' in callSign) throw new Error(callSign.error.message);
 
-        const signedPsbts = Psbt.fromBase64(callSign.result.psbt); //signed.map((hex) => Psbt.fromHex(hex));
-
-        /*for (let i = 0; i < signedPsbts.length; i++) {
-            const psbtOriginal = transactions[i];
-            const psbtSigned = signedPsbts[i];
-
-            psbtOriginal.combine(psbtSigned);
-        }*/
+        const signedPsbts = Psbt.fromBase64(callSign.result.psbt);
 
         transactions[0].combine(signedPsbts);
     }
@@ -342,10 +336,17 @@ export class XverseSigner extends CustomKeypair {
         };
 
         const psbt = transaction.toBase64();
-        const callSign = (await this.BitcoinProvider.request('signPsbt', {
+
+        const toSignInputs: {
+            [x: string]: number[];
+        } = {
+            [this.p2wpkh]: opts.toSignInputs?.map((input) => input.index) || [],
+        };
+
+        const callSign = await this.BitcoinProvider.request('signPsbt', {
             psbt,
-            signInputs: opts.toSignInputs,
-        })) as XverseRPCSignPsbtResponse;
+            signInputs: toSignInputs,
+        });
 
         if ('error' in callSign) throw new Error(callSign.error.message);
 

package/src/transaction/browser/types/Xverse.ts

@@ -4,38 +4,50 @@ export enum XverseNetwork {
     signet = 'Signet',
 }
 
-export type XverseRPCResponse<T = unknown> = {
-    id: string;
-    jsonrpc: string;
-    result: T;
-};
-
-export type XverseRPCError = {
-    id: string;
-    jsonrpc: string;
-    error: {
-        code: number;
-        message: string;
-    };
+type XverseRPCResponse<T = unknown> =
+    | {
+          id: string;
+          jsonrpc: string;
+          result: T;
+      }
+    | {
+          id: string;
+          jsonrpc: string;
+          error: {
+              code: number;
+              message: string;
+          };
+      };
+
+type XverseRPCGetAccountResponse = XverseRPCResponse<{
+    addresses: {
+        address: string;
+        addressType: string;
+        publicKey: string;
+        purpose: 'stacks' | 'payment' | 'ordinals'; // we only care about payment
+    }[];
+    walletType: string;
+}>;
+
+type XverseRPCSignPsbtResponse = XverseRPCResponse<{
+    psbt: string;
+}>;
+
+type XverseRPCGetBalanceResponse = XverseRPCResponse<{
+    confirmed: string;
+    total: string;
+    unconfirmed: string;
+}>;
+
+export type XVersePSBTInput = {
+    psbt: string;
+    signInputs:
+        | {
+              [x: string]: number[];
+          }
+        | undefined;
 };
 
-export type XverseRPCGetAccountResponse =
-    | XverseRPCResponse<{
-          addresses: {
-              address: string;
-              addressType: string;
-              publicKey: string;
-              purpose: string; // ordinals, payment or stacks (we only care about payment)
-          }[];
-      }>
-    | XverseRPCError;
-
-export type XverseRPCSignPsbtResponse =
-    | XverseRPCResponse<{
-          psbt: string;
-      }>
-    | XverseRPCError;
-
 interface InscriptionData {
     address: string;
     amount: number;
@@ -82,23 +94,25 @@ interface SignedTransactionResult {
 }
 
 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[]>;
-
     signTransaction: (transaction: BtcTransaction) => Promise<SignedTransactionResult>;
 }

package/src/transaction/builders/ChallengeSolutionTransaction.ts

@@ -0,0 +1,88 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { IChallengeSolutionTransactionParameters } from '../interfaces/ITransactionParameters.js';
+import { getFinalScripts, opcodes, Psbt, PsbtInput, script, Signer } from '@btc-vision/bitcoin';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { ECPairInterface } from 'ecpair';
+
+export class ChallengeSolutionTransaction extends TransactionBuilder<TransactionType.CHALLENGE_SOLUTION> {
+    public readonly type: TransactionType.CHALLENGE_SOLUTION = TransactionType.CHALLENGE_SOLUTION;
+
+    protected amount: bigint;
+    protected readonly challengeSolution: Buffer;
+
+    constructor(parameters: IChallengeSolutionTransactionParameters) {
+        super(parameters);
+
+        this.amount = parameters.amount;
+        this.challengeSolution = parameters.challengeSolution;
+
+        this.internalInit();
+    }
+
+    protected override async buildTransaction(): Promise<void> {
+        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());
+    }
+
+    protected override async signInput(
+        transaction: Psbt,
+        input: PsbtInput,
+        i: number,
+        signer: Signer | ECPairInterface,
+        reverse: boolean = false,
+        errored: boolean = false,
+    ): Promise<void> {
+        // do nothing.
+    }
+
+    protected override customFinalizerP2SH = (
+        inputIndex: number,
+        input: PsbtInput,
+        scriptA: Buffer,
+        isSegwit: boolean,
+        isP2SH: boolean,
+        isP2WSH: boolean,
+    ): {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    } => {
+        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);
+    };
+
+    protected override getSignerKey(): Signer | ECPairInterface {
+        return this.signer;
+    }
+}

package/src/transaction/builders/DeploymentTransaction.ts

@@ -9,7 +9,11 @@ import {
     Taptree,
     toXOnly,
 } from '@btc-vision/bitcoin';
-import { TransactionBuilder } from './TransactionBuilder.js';
+import {
+    MINIMUM_AMOUNT_CA,
+    MINIMUM_AMOUNT_REWARD,
+    TransactionBuilder,
+} from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { DeploymentGenerator } from '../../generators/builders/DeploymentGenerator.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -19,12 +23,17 @@ import { SharedInteractionTransaction } from './SharedInteractionTransaction.js'
 import { ECPairInterface } from 'ecpair';
 import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { ChallengeGenerator, IMineableReward } from '../mineable/ChallengeGenerator.js';
 
 const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
+
+    protected readonly preimage: Buffer; // ALWAYS 128 bytes for the preimage
+    protected readonly rewardChallenge: IMineableReward;
+
     /**
      * The contract address
      * @protected
@@ -110,6 +119,12 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         }
 
         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);
@@ -123,6 +138,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.compiledTargetScript = this.deploymentGenerator.compile(
             this.bytecode,
             this.randomBytes,
+            this.preimage,
             this.calldata,
         );
 
@@ -163,6 +179,14 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         return this.randomBytes;
     }
 
+    /**
+     * Get the contract bytecode
+     * @returns {Buffer} The contract bytecode
+     */
+    public getPreimage(): Buffer {
+        return this.preimage;
+    }
+
     /**
      * Get the contract signer public key
      * @protected
@@ -205,11 +229,31 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.addInputsFromUTXO();
 
         const amountSpent: bigint = this.getTransactionOPNetFee();
+
+        let amountToCA: bigint;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        } else {
+            amountToCA = amountSpent;
+        }
+
+        // ALWAYS THE FIRST INPUT.
         this.addOutput({
-            value: Number(amountSpent),
+            value: Number(amountToCA),
             address: this.contractAddress.p2tr(this.network),
         });
 
+        // ALWAYS SECOND.
+        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());
     }
 
@@ -351,7 +395,6 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
 
         const scriptSolution = [
             this.randomBytes,
-            this.internalPubKeyToXOnly(),
             input.tapScriptSig[0].signature,
             input.tapScriptSig[1].signature,
         ];

package/src/transaction/builders/InteractionTransaction.ts

@@ -30,6 +30,7 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
         this.compiledTargetScript = this.calldataGenerator.compile(
             this.calldata,
             this.contractSecret,
+            this.preimage,
         );
 
         this.scriptTree = this.getScriptTree();

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -1,6 +1,6 @@
 import { address, Payment, Psbt, PsbtInput, Signer, Taptree, toXOnly } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
-import { TransactionBuilder } from './TransactionBuilder.js';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
@@ -8,6 +8,7 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { ChallengeGenerator, IMineableReward } from '../mineable/ChallengeGenerator.js';
 
 /**
  * Shared interaction transaction
@@ -30,6 +31,9 @@ export abstract class SharedInteractionTransaction<
     protected abstract readonly compiledTargetScript: Buffer;
     protected abstract readonly scriptTree: Taptree;
 
+    protected readonly preimage: Buffer; // ALWAYS 128 bytes for the preimage
+    protected readonly rewardChallenge: IMineableReward;
+
     protected calldataGenerator: CalldataGenerator;
 
     /**
@@ -63,7 +67,13 @@ export abstract class SharedInteractionTransaction<
             throw new Error('Calldata is required');
         }
 
+        this.preimage = parameters.preimage || BitcoinUtils.getSafeRandomValues(128);
+
         this.disableAutoRefund = parameters.disableAutoRefund || false;
+        this.rewardChallenge = ChallengeGenerator.generateMineableReward(
+            this.preimage,
+            this.network,
+        );
 
         this.calldata = Compressor.compress(parameters.calldata);
 
@@ -93,6 +103,13 @@ export abstract class SharedInteractionTransaction<
         return this.randomBytes;
     }
 
+    /**
+     * Get the preimage
+     */
+    public getPreimage(): Buffer {
+        return this.preimage;
+    }
+
     /**
      * Generate the secret for the interaction
      * @protected
@@ -134,8 +151,6 @@ export abstract class SharedInteractionTransaction<
      * @throws {Error} If the to address is required
      */
     protected override async buildTransaction(): Promise<void> {
-        if (!this.to) throw new Error('To address is required');
-
         const selectedRedeem = this.scriptSigner
             ? this.targetScriptRedeem
             : this.leftOverFundsScriptRedeem;
@@ -162,16 +177,7 @@ export abstract class SharedInteractionTransaction<
             this.addInputsFromUTXO();
         }
 
-        const amountSpent: bigint = this.getTransactionOPNetFee();
-        this.addOutput({
-            value: Number(amountSpent),
-            address: this.to,
-        });
-
-        const amount = this.addOptionalOutputsAndGetAmount();
-        if (!this.disableAutoRefund) {
-            await this.addRefundOutput(amountSpent + amount);
-        }
+        await this.createMineableRewardOutputs();
     }
 
     /**
@@ -236,7 +242,6 @@ export abstract class SharedInteractionTransaction<
 
         return [
             this.contractSecret,
-            this.internalPubKeyToXOnly(),
             input.tapScriptSig[0].signature,
             input.tapScriptSig[1].signature,
         ] as Buffer[];
@@ -311,6 +316,41 @@ export abstract class SharedInteractionTransaction<
         }
     }
 
+    private async createMineableRewardOutputs(): Promise<void> {
+        if (!this.to) throw new Error('To address is required');
+
+        const amountSpent: bigint = this.getTransactionOPNetFee();
+
+        let amountToCA: bigint;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        } else {
+            amountToCA = amountSpent;
+        }
+
+        // ALWAYS THE FIRST INPUT.
+        this.addOutput({
+            value: Number(amountToCA),
+            address: this.to,
+        });
+
+        // ALWAYS SECOND.
+        if (
+            amountToCA === MINIMUM_AMOUNT_CA &&
+            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD
+        ) {
+            this.addOutput({
+                value: Number(amountSpent - amountToCA),
+                address: this.rewardChallenge.address,
+            });
+        }
+
+        const amount = this.addOptionalOutputsAndGetAmount();
+        if (!this.disableAutoRefund) {
+            await this.addRefundOutput(amountSpent + amount);
+        }
+    }
+
     private async signInputsNonWalletBased(transaction: Psbt): Promise<void> {
         for (let i = 0; i < transaction.data.inputs.length; i++) {
             if (i === 0) {

package/src/transaction/builders/TransactionBuilder.ts

@@ -26,6 +26,9 @@ import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
 initEccLib(ecc);
 
+export const MINIMUM_AMOUNT_REWARD: bigint = 540n;
+export const MINIMUM_AMOUNT_CA: bigint = 330n;
+
 /**
  * Allows to build a transaction like you would on Ethereum.
  * @description The transaction builder class