@hsuite/native-connect-angular 1.0.0

package/src/lib/services/transaction-builders/xrpl-transaction-builder.service.ts

@@ -0,0 +1,832 @@
+/**
+ * HSuite Native Connect
+ * Copyright 2024-2025 HSuite (https://hsuite.finance)
+ *
+ * SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+ *
+ * This file is part of HSuite Native Connect. For commercial licensing,
+ * visit https://hsuite.finance/licensing
+ */
+
+/**
+ * @file Service for building XRPL (Ripple) transactions using the xrpl package.
+ *
+ * @module services/transaction-builders/xrpl
+ *
+ * @description
+ * XrplTransactionBuilderService provides methods to construct various XRPL transaction
+ * types and serialize them to base64 payloads ready for signing. It supports all major
+ * XRPL transaction types including payments, trust lines, DEX orders, escrows, payment
+ * channels, checks, and NFTs.
+ *
+ * **Supported Transaction Types:**
+ * - Payment - XRP and token transfers
+ * - TrustSet - Trust line creation/modification
+ * - OfferCreate/Cancel - DEX order management
+ * - AccountSet - Account configuration
+ * - EscrowCreate/Finish/Cancel - Escrow operations
+ * - PaymentChannel operations - Payment channels
+ * - Check operations - XRPL checks
+ * - DepositPreauth - Deposit preauthorization
+ * - SignerListSet - Multi-signature configuration
+ * - TicketCreate - Ticket creation
+ * - NFT operations - NFTokenMint, Burn, CreateOffer, etc.
+ * - Batch transactions - Multiple operations atomically
+ *
+ * **Amount Format:**
+ * - XRP amounts are in "drops" (1 XRP = 1,000,000 drops)
+ * - Token amounts use the IssuedCurrency format { currency, issuer, value }
+ */
+
+import { Injectable } from '@angular/core';
+import type {
+  Payment,
+  TrustSet,
+  OfferCreate,
+  OfferCancel,
+  AccountSet,
+  EscrowCreate,
+  EscrowFinish,
+  EscrowCancel,
+  PaymentChannelCreate,
+  PaymentChannelFund,
+  PaymentChannelClaim,
+  CheckCreate,
+  CheckCash,
+  CheckCancel,
+  DepositPreauth,
+  SignerListSet,
+  TicketCreate,
+  NFTokenMint,
+  NFTokenBurn,
+  NFTokenCreateOffer,
+  NFTokenAcceptOffer,
+  NFTokenCancelOffer,
+  Transaction,
+} from 'xrpl';
+
+/**
+ * Service for building XRPL (Ripple) transactions using the xrpl package.
+ *
+ * @service XrplTransactionBuilderService
+ *
+ * @description
+ * Provides methods to construct various XRPL transaction types and serialize them
+ * to base64 payloads ready for signing. All build methods return a base64-encoded
+ * JSON representation of the transaction.
+ *
+ * Unlike Hedera transactions which are frozen with a client, XRPL transactions
+ * are serialized as JSON and can be signed without network connection.
+ *
+ * @providedIn root
+ *
+ * @Component({ ... })
+ * export class SendPage {
+ *   private builder = inject(XrplTransactionBuilderService);
+ *   private wallet = inject(UnifiedWalletService);
+ *
+ *   async sendXrp(to: string, drops: string) {
+ *     const from = this.wallet.activeAccount()?.address;
+ *     const payload = await this.builder.buildPayment(from!, to, drops);
+ *     return this.wallet.submitTransaction({ payload });
+ *   }
+ * }
+ * ```
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class XrplTransactionBuilderService {
+  /**
+   * Builds a Payment transaction (XRP or token).
+   *
+   * @description
+   * Creates a Payment transaction that sends XRP or issued currency tokens
+   * from one account to another. For XRP, the amount is in drops (1 XRP = 1,000,000 drops).
+   *
+   * @param account - Source account address (r...)
+   * @param destination - Destination account address (r...)
+   * @param amount - Amount (XRP in drops, or token value string)
+   * @param isToken - Whether this is a token payment (default: false)
+   * @param currency - Token currency code (required if isToken)
+   * @param issuer - Token issuer address (required if isToken)
+   *
+   * @returns Base64 encoded transaction JSON
+   */
+  async buildPayment(
+    account: string,
+    destination: string,
+    amount: string,
+    isToken = false,
+    currency?: string,
+    issuer?: string,
+  ): Promise<string> {
+    const tx: Payment = {
+      TransactionType: 'Payment',
+      Account: account,
+      Destination: destination,
+      Amount:
+        isToken && currency && issuer
+          ? {
+              currency,
+              issuer,
+              value: amount,
+            }
+          : amount,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Builds a TrustSet transaction to establish or modify a trust line.
+   *
+   * @description
+   * Creates a TrustSet transaction that establishes a trust line between
+   * your account and a token issuer. Trust lines are required before you
+   * can hold issued currency tokens on XRPL.
+   *
+   * @param account - Your account address (r...)
+   * @param currency - Currency code (e.g., 'USD', 'EUR', or hex code)
+   * @param issuer - Token issuer address (r...)
+   * @param limit - Maximum amount willing to hold (e.g., '1000000')
+   *
+   * @returns Base64 encoded transaction JSON
+   */
+  async buildTrustSet(
+    account: string,
+    currency: string,
+    issuer: string,
+    limit: string,
+  ): Promise<string> {
+    const tx: TrustSet = {
+      TransactionType: 'TrustSet',
+      Account: account,
+      LimitAmount: {
+        currency,
+        issuer,
+        value: limit,
+      },
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an OfferCreate transaction (DEX order)
+   * @param account - Account address
+   * @param takerPays - What taker pays (amount object or XRP drops)
+   * @param takerGets - What taker gets (amount object or XRP drops)
+   * @returns Base64 encoded transaction
+   */
+  async buildOfferCreate(
+    account: string,
+    takerPays: string | { currency: string; issuer: string; value: string },
+    takerGets: string | { currency: string; issuer: string; value: string },
+  ): Promise<string> {
+    const tx: OfferCreate = {
+      TransactionType: 'OfferCreate',
+      Account: account,
+      TakerPays: takerPays,
+      TakerGets: takerGets,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an OfferCancel transaction
+   * @param account - Account address
+   * @param offerSequence - Sequence number of the offer to cancel
+   * @returns Base64 encoded transaction
+   */
+  async buildOfferCancel(account: string, offerSequence: number): Promise<string> {
+    const tx: OfferCancel = {
+      TransactionType: 'OfferCancel',
+      Account: account,
+      OfferSequence: offerSequence,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an AccountSet transaction
+   * @param account - Account address
+   * @param options - Account set options (domain, emailHash, flags, etc.)
+   * @param options.domain
+   * @param options.emailHash
+   * @param options.messageKey
+   * @param options.transferRate
+   * @param options.tickSize
+   * @param options.setFlag
+   * @param options.clearFlag
+   * @returns Base64 encoded transaction
+   */
+  async buildAccountSet(
+    account: string,
+    options: {
+      domain?: string;
+      emailHash?: string;
+      messageKey?: string;
+      transferRate?: number;
+      tickSize?: number;
+      setFlag?: number;
+      clearFlag?: number;
+    },
+  ): Promise<string> {
+    const tx: AccountSet = {
+      TransactionType: 'AccountSet',
+      Account: account,
+      ...options,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an EscrowCreate transaction
+   * @param account - Account address
+   * @param destination - Destination account
+   * @param amount - Amount in drops
+   * @param finishAfter - Ripple Epoch (seconds since 2000-01-01 UTC). Callers
+   *   that hold Unix timestamps must convert first; an unmodified Unix value
+   *   would put the escrow ~30 years in the future. The XRPL Time Utilities
+   *   in `xrpl.js` expose helpers, or compute as `unixSeconds - 946684800`.
+   * @param cancelAfter - Optional. Same Ripple Epoch contract as finishAfter.
+   * @returns Base64 encoded transaction
+   */
+  async buildEscrowCreate(
+    account: string,
+    destination: string,
+    amount: string,
+    finishAfter: number,
+    cancelAfter?: number,
+  ): Promise<string> {
+    const tx: EscrowCreate = {
+      TransactionType: 'EscrowCreate',
+      Account: account,
+      Destination: destination,
+      Amount: amount,
+      FinishAfter: finishAfter,
+      ...(cancelAfter && { CancelAfter: cancelAfter }),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an EscrowFinish transaction
+   * @param account - Account address
+   * @param owner - Escrow owner account
+   * @param offerSequence - Sequence number of EscrowCreate transaction
+   * @returns Base64 encoded transaction
+   */
+  async buildEscrowFinish(account: string, owner: string, offerSequence: number): Promise<string> {
+    const tx: EscrowFinish = {
+      TransactionType: 'EscrowFinish',
+      Account: account,
+      Owner: owner,
+      OfferSequence: offerSequence,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an EscrowCancel transaction
+   * @param account - Account address
+   * @param owner - Escrow owner account
+   * @param offerSequence - Sequence number of EscrowCreate transaction
+   * @returns Base64 encoded transaction
+   */
+  async buildEscrowCancel(account: string, owner: string, offerSequence: number): Promise<string> {
+    const tx: EscrowCancel = {
+      TransactionType: 'EscrowCancel',
+      Account: account,
+      Owner: owner,
+      OfferSequence: offerSequence,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a PaymentChannelCreate transaction
+   * @param account - Account address
+   * @param destination - Destination account
+   * @param amount - Amount in drops
+   * @param settleDelay - Settle delay in seconds
+   * @param publicKey - Public key for channel
+   * @returns Base64 encoded transaction
+   */
+  async buildPaymentChannelCreate(
+    account: string,
+    destination: string,
+    amount: string,
+    settleDelay: number,
+    publicKey: string,
+  ): Promise<string> {
+    const tx: PaymentChannelCreate = {
+      TransactionType: 'PaymentChannelCreate',
+      Account: account,
+      Destination: destination,
+      Amount: amount,
+      SettleDelay: settleDelay,
+      PublicKey: publicKey,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a PaymentChannelFund transaction
+   * @param account - Account address
+   * @param channel - Channel ID
+   * @param amount - Amount in drops to add
+   * @returns Base64 encoded transaction
+   */
+  async buildPaymentChannelFund(account: string, channel: string, amount: string): Promise<string> {
+    const tx: PaymentChannelFund = {
+      TransactionType: 'PaymentChannelFund',
+      Account: account,
+      Channel: channel,
+      Amount: amount,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a PaymentChannelClaim transaction
+   * @param account - Account address
+   * @param channel - Channel ID
+   * @param amount - Amount in drops to claim
+   * @returns Base64 encoded transaction
+   */
+  async buildPaymentChannelClaim(
+    account: string,
+    channel: string,
+    amount?: string,
+  ): Promise<string> {
+    const tx: PaymentChannelClaim = {
+      TransactionType: 'PaymentChannelClaim',
+      Account: account,
+      Channel: channel,
+      ...(amount && { Amount: amount }),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a CheckCreate transaction
+   * @param account - Account address
+   * @param destination - Destination account
+   * @param sendMax - Maximum amount that can be cashed
+   * @returns Base64 encoded transaction
+   */
+  async buildCheckCreate(account: string, destination: string, sendMax: string): Promise<string> {
+    const tx: CheckCreate = {
+      TransactionType: 'CheckCreate',
+      Account: account,
+      Destination: destination,
+      SendMax: sendMax,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a CheckCash transaction
+   * @param account - Account address
+   * @param checkID - Check ID to cash
+   * @param amount - Amount to cash (optional, uses DeliverMin if not provided)
+   * @param deliverMin - Minimum amount to deliver (optional)
+   * @returns Base64 encoded transaction
+   */
+  async buildCheckCash(
+    account: string,
+    checkID: string,
+    amount?: string,
+    deliverMin?: string,
+  ): Promise<string> {
+    const tx: CheckCash = {
+      TransactionType: 'CheckCash',
+      Account: account,
+      CheckID: checkID,
+      ...(amount && { Amount: amount }),
+      ...(deliverMin && { DeliverMin: deliverMin }),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a CheckCancel transaction
+   * @param account - Account address
+   * @param checkID - Check ID to cancel
+   * @returns Base64 encoded transaction
+   */
+  async buildCheckCancel(account: string, checkID: string): Promise<string> {
+    const tx: CheckCancel = {
+      TransactionType: 'CheckCancel',
+      Account: account,
+      CheckID: checkID,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a DepositPreauth transaction
+   * @param account - Account address
+   * @param authorize - Account to preauthorize (optional)
+   * @param unauthorize - Account to remove authorization (optional)
+   * @returns Base64 encoded transaction
+   */
+  async buildDepositPreauth(
+    account: string,
+    authorize?: string,
+    unauthorize?: string,
+  ): Promise<string> {
+    const tx: DepositPreauth = {
+      TransactionType: 'DepositPreauth',
+      Account: account,
+      ...(authorize && { Authorize: authorize }),
+      ...(unauthorize && { Unauthorize: unauthorize }),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a SignerListSet transaction
+   * @param account - Account address
+   * @param signerQuorum - Required signature weight
+   * @param signerEntries - Array of signer entries
+   * @returns Base64 encoded transaction
+   */
+  async buildSignerListSet(
+    account: string,
+    signerQuorum: number,
+    signerEntries: Array<{ account: string; weight: number }>,
+  ): Promise<string> {
+    const tx: SignerListSet = {
+      TransactionType: 'SignerListSet',
+      Account: account,
+      SignerQuorum: signerQuorum,
+      SignerEntries: signerEntries.map((entry) => ({
+        SignerEntry: {
+          Account: entry.account,
+          SignerWeight: entry.weight,
+        },
+      })),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a TicketCreate transaction
+   * @param account - Account address
+   * @param ticketCount - Number of tickets to create
+   * @returns Base64 encoded transaction
+   */
+  async buildTicketCreate(account: string, ticketCount: number): Promise<string> {
+    const tx: TicketCreate = {
+      TransactionType: 'TicketCreate',
+      Account: account,
+      TicketCount: ticketCount,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an NFTokenMint transaction
+   * @param account - Account address
+   * @param uri - NFT URI (hex encoded)
+   * @param flags - NFT flags
+   * @param transferFee - Transfer fee in basis points
+   * @param taxon - NFT taxon
+   * @returns Base64 encoded transaction
+   */
+  async buildNFTMint(
+    account: string,
+    uri: string,
+    flags: number,
+    transferFee: number,
+    taxon: number,
+  ): Promise<string> {
+    const tx: NFTokenMint = {
+      TransactionType: 'NFTokenMint',
+      Account: account,
+      URI: uri,
+      Flags: flags,
+      TransferFee: transferFee,
+      NFTokenTaxon: taxon,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an NFTokenBurn transaction
+   * @param account - Account address
+   * @param nftokenID - NFT ID to burn
+   * @returns Base64 encoded transaction
+   */
+  async buildNFTBurn(account: string, nftokenID: string): Promise<string> {
+    const tx: NFTokenBurn = {
+      TransactionType: 'NFTokenBurn',
+      Account: account,
+      NFTokenID: nftokenID,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an NFTokenCreateOffer transaction
+   * @param account - Account address
+   * @param nftokenID - NFT ID
+   * @param amount - Offer amount
+   * @param flags - Offer flags (1=sell, 0=buy)
+   * @param destination - Optional destination account
+   * @returns Base64 encoded transaction
+   */
+  async buildNFTCreateOffer(
+    account: string,
+    nftokenID: string,
+    amount: string,
+    flags: number,
+    destination?: string,
+  ): Promise<string> {
+    const tx: NFTokenCreateOffer = {
+      TransactionType: 'NFTokenCreateOffer',
+      Account: account,
+      NFTokenID: nftokenID,
+      Amount: amount,
+      Flags: flags,
+      ...(destination && { Destination: destination }),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an NFTokenAcceptOffer transaction
+   * @param account - Account address
+   * @param nftokenSellOffer - Sell offer ID (optional)
+   * @param nftokenBuyOffer - Buy offer ID (optional)
+   * @returns Base64 encoded transaction
+   */
+  async buildNFTAcceptOffer(
+    account: string,
+    nftokenSellOffer?: string,
+    nftokenBuyOffer?: string,
+  ): Promise<string> {
+    const tx: NFTokenAcceptOffer = {
+      TransactionType: 'NFTokenAcceptOffer',
+      Account: account,
+      ...(nftokenSellOffer && { NFTokenSellOffer: nftokenSellOffer }),
+      ...(nftokenBuyOffer && { NFTokenBuyOffer: nftokenBuyOffer }),
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build an NFTokenCancelOffer transaction
+   * @param account - Account address
+   * @param nftokenOffers - Array of offer IDs to cancel
+   * @returns Base64 encoded transaction
+   */
+  async buildNFTCancelOffer(account: string, nftokenOffers: string[]): Promise<string> {
+    const tx: NFTokenCancelOffer = {
+      TransactionType: 'NFTokenCancelOffer',
+      Account: account,
+      NFTokenOffers: nftokenOffers,
+    };
+
+    return this.serializeTransaction(tx);
+  }
+
+  /**
+   * Build a Batch transaction with multiple inner transactions
+   * @param account - Account executing the batch
+   * @param innerTransactions - Array of transaction descriptors
+   * @returns Base64 encoded batch transaction JSON
+   */
+  async buildBatchTransaction(
+    account: string,
+    innerTransactions: Array<{
+      type: 'payment' | 'trust-set' | 'nft-mint';
+      destination?: string;
+      amount?: string;
+      currency?: string;
+      issuer?: string;
+    }>,
+  ): Promise<string> {
+    const tfInnerBatchTxn = 1073741824;
+    const tfAllOrNothing = 65536;
+
+    const rawTransactions = innerTransactions.map((tx, index) => {
+      let innerTx: any;
+
+      switch (tx.type) {
+        case 'payment':
+          innerTx = {
+            TransactionType: 'Payment',
+            Flags: tfInnerBatchTxn,
+            Account: account,
+            Destination: tx.destination || '',
+            Amount: tx.amount || '1000000',
+            Fee: '0',
+            Sequence: index + 1,
+            SigningPubKey: '',
+          };
+
+          if (tx.currency && tx.issuer) {
+            innerTx.Amount = {
+              currency: tx.currency,
+              issuer: tx.issuer,
+              value: tx.amount || '1',
+            };
+          }
+          break;
+
+        case 'trust-set':
+          innerTx = {
+            TransactionType: 'TrustSet',
+            Flags: tfInnerBatchTxn,
+            Account: account,
+            LimitAmount: {
+              currency: tx.currency || 'USD',
+              issuer: tx.issuer || '',
+              value: tx.amount || '1000000',
+            },
+            Fee: '0',
+            Sequence: index + 1,
+            SigningPubKey: '',
+          };
+          break;
+
+        case 'nft-mint':
+          innerTx = {
+            TransactionType: 'NFTokenMint',
+            Flags: tfInnerBatchTxn,
+            Account: account,
+            NFTokenTaxon: 0,
+            Fee: '0',
+            Sequence: index + 1,
+            SigningPubKey: '',
+          };
+          break;
+
+        default:
+          innerTx = {
+            TransactionType: 'Payment',
+            Flags: tfInnerBatchTxn,
+            Account: account,
+            Destination: account,
+            Amount: '1',
+            Fee: '0',
+            Sequence: index + 1,
+            SigningPubKey: '',
+          };
+      }
+
+      return { RawTransaction: innerTx };
+    });
+
+    const batchTx = {
+      TransactionType: 'Batch',
+      Account: account,
+      Flags: tfAllOrNothing,
+      RawTransactions: rawTransactions,
+    };
+
+    return this.serializeTransaction(batchTx as any);
+  }
+
+  /**
+   * Build inner transactions for batch (unsigned, with batch flags set)
+   * @param account - Account executing the batch
+   * @param innerTransactions - Array of transaction descriptors
+   * @returns Array of base64 encoded unsigned inner transactions
+   */
+  async buildBatchInnerTransactions(
+    account: string,
+    innerTransactions: Array<{
+      type: 'payment' | 'trust-set' | 'nft-mint';
+      destination?: string;
+      amount?: string;
+      currency?: string;
+      issuer?: string;
+      uri?: string;
+      taxon?: number;
+    }>,
+  ): Promise<Array<{ payload: string; description: string }>> {
+    const tfInnerBatchTxn = 1073741824;
+    const results: Array<{ payload: string; description: string }> = [];
+
+    for (let index = 0; index < innerTransactions.length; index++) {
+      const tx = innerTransactions[index];
+      let innerTx: any;
+      let description: string;
+
+      switch (tx.type) {
+        case 'payment':
+          if (tx.currency && tx.issuer) {
+            innerTx = {
+              TransactionType: 'Payment',
+              Flags: tfInnerBatchTxn,
+              Account: account,
+              Destination: tx.destination || '',
+              Amount: {
+                currency: tx.currency,
+                issuer: tx.issuer,
+                value: tx.amount || '1',
+              },
+              Fee: '0',
+              Sequence: index + 1,
+              SigningPubKey: '',
+            };
+            description = `Send ${tx.amount} ${tx.currency} to ${tx.destination}`;
+          } else {
+            innerTx = {
+              TransactionType: 'Payment',
+              Flags: tfInnerBatchTxn,
+              Account: account,
+              Destination: tx.destination || '',
+              Amount: tx.amount || '1000000',
+              Fee: '0',
+              Sequence: index + 1,
+              SigningPubKey: '',
+            };
+            description = `Send ${Number(tx.amount || '1000000') / 1000000} XRP to ${tx.destination}`;
+          }
+          break;
+
+        case 'trust-set':
+          innerTx = {
+            TransactionType: 'TrustSet',
+            Flags: tfInnerBatchTxn,
+            Account: account,
+            LimitAmount: {
+              currency: tx.currency || 'USD',
+              issuer: tx.issuer || '',
+              value: tx.amount || '1000000',
+            },
+            Fee: '0',
+            Sequence: index + 1,
+            SigningPubKey: '',
+          };
+          description = `Set trust line for ${tx.currency} (${tx.amount})`;
+          break;
+
+        case 'nft-mint':
+          innerTx = {
+            TransactionType: 'NFTokenMint',
+            Flags: tfInnerBatchTxn,
+            Account: account,
+            URI: tx.uri || '',
+            NFTokenTaxon: tx.taxon || 0,
+            Fee: '0',
+            Sequence: index + 1,
+            SigningPubKey: '',
+          };
+          description = `Mint NFT (taxon: ${tx.taxon})`;
+          break;
+
+        default:
+          throw new Error(`Unknown transaction type: ${(tx as any).type}`);
+      }
+
+      results.push({
+        payload: btoa(JSON.stringify(innerTx)),
+        description,
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Serializes a transaction to base64 encoded JSON.
+   *
+   * @description
+   * Converts the transaction object to a JSON string and encodes it as base64.
+   * This format is used for transport to the wallet for signing.
+   *
+   * @param transaction - The XRPL transaction object
+   *
+   * @returns Base64 encoded JSON string
+   */
+  private async serializeTransaction(transaction: Transaction): Promise<string> {
+    const jsonString = JSON.stringify(transaction);
+    return btoa(jsonString);
+  }
+}