@hsuite/native-connect-angular 1.0.0

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

@@ -0,0 +1,937 @@
+/**
+ * @fileoverview Unit tests for XrplTransactionBuilderService
+ *
+ * Tests cover:
+ * - Payment transactions (XRP and tokens)
+ * - TrustSet transactions
+ * - Offer/DEX transactions (create, cancel)
+ * - AccountSet transactions
+ * - Escrow transactions (create, finish, cancel)
+ * - Payment channel transactions
+ * - Check transactions (create, cash, cancel)
+ * - DepositPreauth transactions
+ * - SignerListSet transactions
+ * - TicketCreate transactions
+ * - NFT transactions (mint, burn, create/accept/cancel offers)
+ * - Batch transactions
+ * - Error handling
+ *
+ * @module services/transaction-builders/xrpl-transaction-builder
+ * @since 2.0.0
+ */
+
+import { TestBed } from '@angular/core/testing';
+import { describe, it, expect, beforeEach } from 'vitest';
+import { XrplTransactionBuilderService } from './xrpl-transaction-builder.service';
+
+describe('XrplTransactionBuilderService', () => {
+  let service: XrplTransactionBuilderService;
+
+  const mockAccount = 'rAccountSourceXXXXXXXXXXXXXX';
+  const mockDestination = 'rAccountDestXXXXXXXXXXXXXXX';
+  const mockIssuer = 'rIssuerAccountXXXXXXXXXXXXXX';
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      providers: [XrplTransactionBuilderService],
+    }).compileComponents();
+
+    service = TestBed.inject(XrplTransactionBuilderService);
+  });
+
+  it('should create', () => {
+    expect(service).toBeTruthy();
+  });
+
+  /**
+   * Helper to decode and parse base64 transaction
+   */
+  function decodeTransaction(base64: string): Record<string, unknown> {
+    const json = atob(base64);
+    return JSON.parse(json);
+  }
+
+  // ==================== PAYMENT TRANSACTIONS ====================
+  describe('buildPayment', () => {
+    it('should build XRP payment transaction', async () => {
+      const amount = '1000000'; // 1 XRP in drops
+      const result = await service.buildPayment(mockAccount, mockDestination, amount);
+
+      expect(result).toBeDefined();
+      expect(typeof result).toBe('string');
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('Payment');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Destination).toBe(mockDestination);
+      expect(tx.Amount).toBe(amount);
+    });
+
+    it('should build token payment transaction', async () => {
+      const amount = '100';
+      const currency = 'USD';
+
+      const result = await service.buildPayment(
+        mockAccount,
+        mockDestination,
+        amount,
+        true,
+        currency,
+        mockIssuer
+      );
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('Payment');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Destination).toBe(mockDestination);
+      expect(tx.Amount).toEqual({
+        currency,
+        issuer: mockIssuer,
+        value: amount,
+      });
+    });
+
+    it('should default to XRP payment when isToken is false', async () => {
+      const amount = '5000000';
+      const result = await service.buildPayment(mockAccount, mockDestination, amount, false);
+
+      const tx = decodeTransaction(result);
+      expect(tx.Amount).toBe(amount);
+    });
+
+    it('should treat as XRP payment when isToken is true but no currency/issuer provided', async () => {
+      const amount = '5000000';
+      const result = await service.buildPayment(mockAccount, mockDestination, amount, true);
+
+      const tx = decodeTransaction(result);
+      // When isToken is true but currency/issuer are missing, it falls back to XRP
+      expect(tx.Amount).toBe(amount);
+    });
+  });
+
+  // ==================== TRUSTSET TRANSACTIONS ====================
+  describe('buildTrustSet', () => {
+    it('should build TrustSet transaction', async () => {
+      const currency = 'USD';
+      const limit = '1000000';
+
+      const result = await service.buildTrustSet(mockAccount, currency, mockIssuer, limit);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('TrustSet');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.LimitAmount).toEqual({
+        currency,
+        issuer: mockIssuer,
+        value: limit,
+      });
+    });
+
+    it('should handle different currency codes', async () => {
+      const currencies = ['EUR', 'GBP', 'JPY', 'BTC'];
+
+      for (const currency of currencies) {
+        const result = await service.buildTrustSet(mockAccount, currency, mockIssuer, '100000');
+        const tx = decodeTransaction(result);
+        expect(tx.LimitAmount).toHaveProperty('currency', currency);
+      }
+    });
+  });
+
+  // ==================== OFFER TRANSACTIONS ====================
+  describe('buildOfferCreate', () => {
+    it('should build OfferCreate with XRP amounts', async () => {
+      const takerPays = '1000000';
+      const takerGets = '500000';
+
+      const result = await service.buildOfferCreate(mockAccount, takerPays, takerGets);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('OfferCreate');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.TakerPays).toBe(takerPays);
+      expect(tx.TakerGets).toBe(takerGets);
+    });
+
+    it('should build OfferCreate with token amounts', async () => {
+      const takerPays = { currency: 'USD', issuer: mockIssuer, value: '100' };
+      const takerGets = { currency: 'EUR', issuer: mockIssuer, value: '85' };
+
+      const result = await service.buildOfferCreate(mockAccount, takerPays, takerGets);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TakerPays).toEqual(takerPays);
+      expect(tx.TakerGets).toEqual(takerGets);
+    });
+
+    it('should build OfferCreate with mixed XRP/token amounts', async () => {
+      const takerPays = '1000000'; // XRP
+      const takerGets = { currency: 'USD', issuer: mockIssuer, value: '100' };
+
+      const result = await service.buildOfferCreate(mockAccount, takerPays, takerGets);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TakerPays).toBe(takerPays);
+      expect(tx.TakerGets).toEqual(takerGets);
+    });
+  });
+
+  describe('buildOfferCancel', () => {
+    it('should build OfferCancel transaction', async () => {
+      const offerSequence = 12345;
+
+      const result = await service.buildOfferCancel(mockAccount, offerSequence);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('OfferCancel');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.OfferSequence).toBe(offerSequence);
+    });
+  });
+
+  // ==================== ACCOUNTSET TRANSACTIONS ====================
+  describe('buildAccountSet', () => {
+    it('should build AccountSet with domain', async () => {
+      const domain = '6578616D706C652E636F6D'; // example.com in hex
+
+      const result = await service.buildAccountSet(mockAccount, { domain });
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('AccountSet');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.domain).toBe(domain);
+    });
+
+    it('should build AccountSet with multiple options', async () => {
+      const options = {
+        domain: '6578616D706C652E636F6D',
+        emailHash: 'abcd1234',
+        transferRate: 1005000000,
+        tickSize: 5,
+        setFlag: 8,
+      };
+
+      const result = await service.buildAccountSet(mockAccount, options);
+
+      const tx = decodeTransaction(result);
+      expect(tx.domain).toBe(options.domain);
+      expect(tx.emailHash).toBe(options.emailHash);
+      expect(tx.transferRate).toBe(options.transferRate);
+      expect(tx.tickSize).toBe(options.tickSize);
+      expect(tx.setFlag).toBe(options.setFlag);
+    });
+
+    it('should build AccountSet with clearFlag', async () => {
+      const result = await service.buildAccountSet(mockAccount, { clearFlag: 8 });
+
+      const tx = decodeTransaction(result);
+      expect(tx.clearFlag).toBe(8);
+    });
+
+    it('should build AccountSet with empty options', async () => {
+      const result = await service.buildAccountSet(mockAccount, {});
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('AccountSet');
+      expect(tx.Account).toBe(mockAccount);
+    });
+  });
+
+  // ==================== ESCROW TRANSACTIONS ====================
+  describe('buildEscrowCreate', () => {
+    it('should build EscrowCreate without cancelAfter', async () => {
+      const amount = '1000000';
+      const finishAfter = 1700000000;
+
+      const result = await service.buildEscrowCreate(
+        mockAccount,
+        mockDestination,
+        amount,
+        finishAfter
+      );
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('EscrowCreate');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Destination).toBe(mockDestination);
+      expect(tx.Amount).toBe(amount);
+      expect(tx.FinishAfter).toBe(finishAfter);
+      expect(tx.CancelAfter).toBeUndefined();
+    });
+
+    it('should build EscrowCreate with cancelAfter', async () => {
+      const amount = '1000000';
+      const finishAfter = 1700000000;
+      const cancelAfter = 1800000000;
+
+      const result = await service.buildEscrowCreate(
+        mockAccount,
+        mockDestination,
+        amount,
+        finishAfter,
+        cancelAfter
+      );
+
+      const tx = decodeTransaction(result);
+      expect(tx.FinishAfter).toBe(finishAfter);
+      expect(tx.CancelAfter).toBe(cancelAfter);
+    });
+  });
+
+  describe('buildEscrowFinish', () => {
+    it('should build EscrowFinish transaction', async () => {
+      const owner = 'rOwnerAccountXXXXXXXXXXXXXXX';
+      const offerSequence = 54321;
+
+      const result = await service.buildEscrowFinish(mockAccount, owner, offerSequence);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('EscrowFinish');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Owner).toBe(owner);
+      expect(tx.OfferSequence).toBe(offerSequence);
+    });
+  });
+
+  describe('buildEscrowCancel', () => {
+    it('should build EscrowCancel transaction', async () => {
+      const owner = 'rOwnerAccountXXXXXXXXXXXXXXX';
+      const offerSequence = 54321;
+
+      const result = await service.buildEscrowCancel(mockAccount, owner, offerSequence);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('EscrowCancel');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Owner).toBe(owner);
+      expect(tx.OfferSequence).toBe(offerSequence);
+    });
+  });
+
+  // ==================== PAYMENT CHANNEL TRANSACTIONS ====================
+  describe('buildPaymentChannelCreate', () => {
+    it('should build PaymentChannelCreate transaction', async () => {
+      const amount = '10000000';
+      const settleDelay = 86400;
+      const publicKey = '03abcdef1234567890';
+
+      const result = await service.buildPaymentChannelCreate(
+        mockAccount,
+        mockDestination,
+        amount,
+        settleDelay,
+        publicKey
+      );
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('PaymentChannelCreate');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Destination).toBe(mockDestination);
+      expect(tx.Amount).toBe(amount);
+      expect(tx.SettleDelay).toBe(settleDelay);
+      expect(tx.PublicKey).toBe(publicKey);
+    });
+  });
+
+  describe('buildPaymentChannelFund', () => {
+    it('should build PaymentChannelFund transaction', async () => {
+      const channel = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+      const amount = '5000000';
+
+      const result = await service.buildPaymentChannelFund(mockAccount, channel, amount);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('PaymentChannelFund');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Channel).toBe(channel);
+      expect(tx.Amount).toBe(amount);
+    });
+  });
+
+  describe('buildPaymentChannelClaim', () => {
+    it('should build PaymentChannelClaim with amount', async () => {
+      const channel = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+      const amount = '1000000';
+
+      const result = await service.buildPaymentChannelClaim(mockAccount, channel, amount);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('PaymentChannelClaim');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Channel).toBe(channel);
+      expect(tx.Amount).toBe(amount);
+    });
+
+    it('should build PaymentChannelClaim without amount', async () => {
+      const channel = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+
+      const result = await service.buildPaymentChannelClaim(mockAccount, channel);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('PaymentChannelClaim');
+      expect(tx.Channel).toBe(channel);
+      expect(tx.Amount).toBeUndefined();
+    });
+  });
+
+  // ==================== CHECK TRANSACTIONS ====================
+  describe('buildCheckCreate', () => {
+    it('should build CheckCreate transaction', async () => {
+      const sendMax = '5000000';
+
+      const result = await service.buildCheckCreate(mockAccount, mockDestination, sendMax);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('CheckCreate');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Destination).toBe(mockDestination);
+      expect(tx.SendMax).toBe(sendMax);
+    });
+  });
+
+  describe('buildCheckCash', () => {
+    it('should build CheckCash with amount', async () => {
+      const checkID = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+      const amount = '4000000';
+
+      const result = await service.buildCheckCash(mockAccount, checkID, amount);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('CheckCash');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.CheckID).toBe(checkID);
+      expect(tx.Amount).toBe(amount);
+      expect(tx.DeliverMin).toBeUndefined();
+    });
+
+    it('should build CheckCash with deliverMin', async () => {
+      const checkID = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+      const deliverMin = '3500000';
+
+      const result = await service.buildCheckCash(mockAccount, checkID, undefined, deliverMin);
+
+      const tx = decodeTransaction(result);
+      expect(tx.Amount).toBeUndefined();
+      expect(tx.DeliverMin).toBe(deliverMin);
+    });
+
+    it('should build CheckCash with both amount and deliverMin', async () => {
+      const checkID = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+      const amount = '4000000';
+      const deliverMin = '3500000';
+
+      const result = await service.buildCheckCash(mockAccount, checkID, amount, deliverMin);
+
+      const tx = decodeTransaction(result);
+      expect(tx.Amount).toBe(amount);
+      expect(tx.DeliverMin).toBe(deliverMin);
+    });
+
+    it('should build CheckCash with neither amount nor deliverMin', async () => {
+      const checkID = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+
+      const result = await service.buildCheckCash(mockAccount, checkID);
+
+      const tx = decodeTransaction(result);
+      expect(tx.CheckID).toBe(checkID);
+      expect(tx.Amount).toBeUndefined();
+      expect(tx.DeliverMin).toBeUndefined();
+    });
+  });
+
+  describe('buildCheckCancel', () => {
+    it('should build CheckCancel transaction', async () => {
+      const checkID = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+
+      const result = await service.buildCheckCancel(mockAccount, checkID);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('CheckCancel');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.CheckID).toBe(checkID);
+    });
+  });
+
+  // ==================== DEPOSITPREAUTH TRANSACTIONS ====================
+  describe('buildDepositPreauth', () => {
+    it('should build DepositPreauth with authorize', async () => {
+      const authorize = 'rAuthorizeAccountXXXXXXXXXXX';
+
+      const result = await service.buildDepositPreauth(mockAccount, authorize);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('DepositPreauth');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Authorize).toBe(authorize);
+      expect(tx.Unauthorize).toBeUndefined();
+    });
+
+    it('should build DepositPreauth with unauthorize', async () => {
+      const unauthorize = 'rUnauthorizeAccountXXXXXXXXX';
+
+      const result = await service.buildDepositPreauth(mockAccount, undefined, unauthorize);
+
+      const tx = decodeTransaction(result);
+      expect(tx.Authorize).toBeUndefined();
+      expect(tx.Unauthorize).toBe(unauthorize);
+    });
+
+    it('should build DepositPreauth with neither authorize nor unauthorize', async () => {
+      const result = await service.buildDepositPreauth(mockAccount);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('DepositPreauth');
+      expect(tx.Account).toBe(mockAccount);
+    });
+  });
+
+  // ==================== SIGNERLISTSET TRANSACTIONS ====================
+  describe('buildSignerListSet', () => {
+    it('should build SignerListSet transaction', async () => {
+      const signerQuorum = 2;
+      const signerEntries = [
+        { account: 'rSigner1XXXXXXXXXXXXXXXXXX', weight: 1 },
+        { account: 'rSigner2XXXXXXXXXXXXXXXXXX', weight: 1 },
+        { account: 'rSigner3XXXXXXXXXXXXXXXXXX', weight: 1 },
+      ];
+
+      const result = await service.buildSignerListSet(mockAccount, signerQuorum, signerEntries);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('SignerListSet');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.SignerQuorum).toBe(signerQuorum);
+      expect(tx.SignerEntries).toEqual([
+        { SignerEntry: { Account: 'rSigner1XXXXXXXXXXXXXXXXXX', SignerWeight: 1 } },
+        { SignerEntry: { Account: 'rSigner2XXXXXXXXXXXXXXXXXX', SignerWeight: 1 } },
+        { SignerEntry: { Account: 'rSigner3XXXXXXXXXXXXXXXXXX', SignerWeight: 1 } },
+      ]);
+    });
+
+    it('should build SignerListSet with different weights', async () => {
+      const signerQuorum = 3;
+      const signerEntries = [
+        { account: 'rSigner1XXXXXXXXXXXXXXXXXX', weight: 2 },
+        { account: 'rSigner2XXXXXXXXXXXXXXXXXX', weight: 1 },
+      ];
+
+      const result = await service.buildSignerListSet(mockAccount, signerQuorum, signerEntries);
+
+      const tx = decodeTransaction(result);
+      expect(tx.SignerQuorum).toBe(3);
+      expect(tx.SignerEntries).toHaveLength(2);
+    });
+
+    it('should build SignerListSet with empty signer list (disable multisig)', async () => {
+      const result = await service.buildSignerListSet(mockAccount, 0, []);
+
+      const tx = decodeTransaction(result);
+      expect(tx.SignerQuorum).toBe(0);
+      expect(tx.SignerEntries).toEqual([]);
+    });
+  });
+
+  // ==================== TICKETCREATE TRANSACTIONS ====================
+  describe('buildTicketCreate', () => {
+    it('should build TicketCreate transaction', async () => {
+      const ticketCount = 10;
+
+      const result = await service.buildTicketCreate(mockAccount, ticketCount);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('TicketCreate');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.TicketCount).toBe(ticketCount);
+    });
+
+    it('should build TicketCreate with minimum ticket count', async () => {
+      const result = await service.buildTicketCreate(mockAccount, 1);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TicketCount).toBe(1);
+    });
+
+    it('should build TicketCreate with maximum ticket count', async () => {
+      const result = await service.buildTicketCreate(mockAccount, 250);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TicketCount).toBe(250);
+    });
+  });
+
+  // ==================== NFT TRANSACTIONS ====================
+  describe('buildNFTMint', () => {
+    it('should build NFTokenMint transaction', async () => {
+      const uri = '697066733A2F2F6261666B7265696768'; // ipfs://... in hex
+      const flags = 8; // tfTransferable
+      const transferFee = 500; // 5% in basis points
+      const taxon = 0;
+
+      const result = await service.buildNFTMint(mockAccount, uri, flags, transferFee, taxon);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('NFTokenMint');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.URI).toBe(uri);
+      expect(tx.Flags).toBe(flags);
+      expect(tx.TransferFee).toBe(transferFee);
+      expect(tx.NFTokenTaxon).toBe(taxon);
+    });
+
+    it('should build NFTokenMint with different taxons', async () => {
+      const taxons = [0, 1, 100, 999999];
+
+      for (const taxon of taxons) {
+        const result = await service.buildNFTMint(mockAccount, 'abc', 0, 0, taxon);
+        const tx = decodeTransaction(result);
+        expect(tx.NFTokenTaxon).toBe(taxon);
+      }
+    });
+  });
+
+  describe('buildNFTBurn', () => {
+    it('should build NFTokenBurn transaction', async () => {
+      const nftokenID = '000800006203F49C21D5D6E022CB16DE3538F248662FC73C00000000000001E2';
+
+      const result = await service.buildNFTBurn(mockAccount, nftokenID);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('NFTokenBurn');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.NFTokenID).toBe(nftokenID);
+    });
+  });
+
+  describe('buildNFTCreateOffer', () => {
+    it('should build NFTokenCreateOffer for sell', async () => {
+      const nftokenID = '000800006203F49C21D5D6E022CB16DE3538F248662FC73C00000000000001E2';
+      const amount = '1000000';
+      const flags = 1; // tfSellNFToken
+
+      const result = await service.buildNFTCreateOffer(mockAccount, nftokenID, amount, flags);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('NFTokenCreateOffer');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.NFTokenID).toBe(nftokenID);
+      expect(tx.Amount).toBe(amount);
+      expect(tx.Flags).toBe(flags);
+      expect(tx.Destination).toBeUndefined();
+    });
+
+    it('should build NFTokenCreateOffer for buy', async () => {
+      const nftokenID = '000800006203F49C21D5D6E022CB16DE3538F248662FC73C00000000000001E2';
+      const amount = '500000';
+      const flags = 0; // Buy offer
+
+      const result = await service.buildNFTCreateOffer(mockAccount, nftokenID, amount, flags);
+
+      const tx = decodeTransaction(result);
+      expect(tx.Flags).toBe(0);
+    });
+
+    it('should build NFTokenCreateOffer with destination', async () => {
+      const nftokenID = '000800006203F49C21D5D6E022CB16DE3538F248662FC73C00000000000001E2';
+      const amount = '1000000';
+      const flags = 1;
+
+      const result = await service.buildNFTCreateOffer(
+        mockAccount,
+        nftokenID,
+        amount,
+        flags,
+        mockDestination
+      );
+
+      const tx = decodeTransaction(result);
+      expect(tx.Destination).toBe(mockDestination);
+    });
+  });
+
+  describe('buildNFTAcceptOffer', () => {
+    it('should build NFTokenAcceptOffer with sell offer', async () => {
+      const sellOffer = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+
+      const result = await service.buildNFTAcceptOffer(mockAccount, sellOffer);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('NFTokenAcceptOffer');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.NFTokenSellOffer).toBe(sellOffer);
+      expect(tx.NFTokenBuyOffer).toBeUndefined();
+    });
+
+    it('should build NFTokenAcceptOffer with buy offer', async () => {
+      const buyOffer = 'D2BF7EEEFC16CF3089D1BAE7FF413059E0644802EC859EDEE4C96A03089D1BAE';
+
+      const result = await service.buildNFTAcceptOffer(mockAccount, undefined, buyOffer);
+
+      const tx = decodeTransaction(result);
+      expect(tx.NFTokenSellOffer).toBeUndefined();
+      expect(tx.NFTokenBuyOffer).toBe(buyOffer);
+    });
+
+    it('should build NFTokenAcceptOffer with both offers (brokered mode)', async () => {
+      const sellOffer = 'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA';
+      const buyOffer = 'D2BF7EEEFC16CF3089D1BAE7FF413059E0644802EC859EDEE4C96A03089D1BAE';
+
+      const result = await service.buildNFTAcceptOffer(mockAccount, sellOffer, buyOffer);
+
+      const tx = decodeTransaction(result);
+      expect(tx.NFTokenSellOffer).toBe(sellOffer);
+      expect(tx.NFTokenBuyOffer).toBe(buyOffer);
+    });
+  });
+
+  describe('buildNFTCancelOffer', () => {
+    it('should build NFTokenCancelOffer with single offer', async () => {
+      const offers = ['C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA'];
+
+      const result = await service.buildNFTCancelOffer(mockAccount, offers);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('NFTokenCancelOffer');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.NFTokenOffers).toEqual(offers);
+    });
+
+    it('should build NFTokenCancelOffer with multiple offers', async () => {
+      const offers = [
+        'C1AE6DDDEEC05CF2978C0BAD6FE302948E9533691DC749DCDD3B95992978C0BA',
+        'D2BF7EEEFC16CF3089D1BAE7FF413059E0644802EC859EDEE4C96A03089D1BAE',
+        'E3CG8FFFGD27DG4190E2CBF8GG524160F1755913FD960FEEF5D97B14190E2CBF',
+      ];
+
+      const result = await service.buildNFTCancelOffer(mockAccount, offers);
+
+      const tx = decodeTransaction(result);
+      expect(tx.NFTokenOffers).toHaveLength(3);
+    });
+  });
+
+  // ==================== BATCH TRANSACTIONS ====================
+  describe('buildBatchTransaction', () => {
+    const tfAllOrNothing = 65536;
+    const tfInnerBatchTxn = 1073741824;
+
+    it('should build batch with payment transactions', async () => {
+      const innerTransactions = [
+        { type: 'payment' as const, destination: mockDestination, amount: '1000000' },
+        { type: 'payment' as const, destination: 'rAnotherAccount', amount: '2000000' },
+      ];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      expect(tx.TransactionType).toBe('Batch');
+      expect(tx.Account).toBe(mockAccount);
+      expect(tx.Flags).toBe(tfAllOrNothing);
+      expect(tx.RawTransactions).toHaveLength(2);
+    });
+
+    it('should build batch with trust-set transactions', async () => {
+      const innerTransactions = [
+        { type: 'trust-set' as const, currency: 'USD', issuer: mockIssuer, amount: '1000000' },
+      ];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      const rawTx = (tx.RawTransactions as Array<{ RawTransaction: Record<string, unknown> }>)[0];
+      expect(rawTx.RawTransaction.TransactionType).toBe('TrustSet');
+      expect(rawTx.RawTransaction.Flags).toBe(tfInnerBatchTxn);
+    });
+
+    it('should build batch with nft-mint transactions', async () => {
+      const innerTransactions = [{ type: 'nft-mint' as const }];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      const rawTx = (tx.RawTransactions as Array<{ RawTransaction: Record<string, unknown> }>)[0];
+      expect(rawTx.RawTransaction.TransactionType).toBe('NFTokenMint');
+    });
+
+    it('should build batch with token payment', async () => {
+      const innerTransactions = [
+        {
+          type: 'payment' as const,
+          destination: mockDestination,
+          amount: '100',
+          currency: 'USD',
+          issuer: mockIssuer,
+        },
+      ];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      const rawTx = (tx.RawTransactions as Array<{ RawTransaction: Record<string, unknown> }>)[0];
+      expect(rawTx.RawTransaction.Amount).toEqual({
+        currency: 'USD',
+        issuer: mockIssuer,
+        value: '100',
+      });
+    });
+
+    it('should build batch with default payment for unknown type', async () => {
+      const innerTransactions = [{ type: 'unknown' as any }];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      const rawTx = (tx.RawTransactions as Array<{ RawTransaction: Record<string, unknown> }>)[0];
+      expect(rawTx.RawTransaction.TransactionType).toBe('Payment');
+      expect(rawTx.RawTransaction.Amount).toBe('1');
+    });
+
+    it('should set correct sequence numbers for inner transactions', async () => {
+      const innerTransactions = [
+        { type: 'payment' as const, destination: mockDestination, amount: '1000000' },
+        { type: 'payment' as const, destination: mockDestination, amount: '2000000' },
+        { type: 'payment' as const, destination: mockDestination, amount: '3000000' },
+      ];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      const rawTxs = tx.RawTransactions as Array<{ RawTransaction: Record<string, unknown> }>;
+      expect(rawTxs[0].RawTransaction.Sequence).toBe(1);
+      expect(rawTxs[1].RawTransaction.Sequence).toBe(2);
+      expect(rawTxs[2].RawTransaction.Sequence).toBe(3);
+    });
+
+    it('should set Fee to 0 and empty SigningPubKey for inner transactions', async () => {
+      const innerTransactions = [
+        { type: 'payment' as const, destination: mockDestination, amount: '1000000' },
+      ];
+
+      const result = await service.buildBatchTransaction(mockAccount, innerTransactions);
+
+      const tx = decodeTransaction(result);
+      const rawTx = (tx.RawTransactions as Array<{ RawTransaction: Record<string, unknown> }>)[0];
+      expect(rawTx.RawTransaction.Fee).toBe('0');
+      expect(rawTx.RawTransaction.SigningPubKey).toBe('');
+    });
+  });
+
+  describe('buildBatchInnerTransactions', () => {
+    it('should build inner transactions with payment (XRP)', async () => {
+      const innerTransactions = [
+        { type: 'payment' as const, destination: mockDestination, amount: '1000000' },
+      ];
+
+      const result = await service.buildBatchInnerTransactions(mockAccount, innerTransactions);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].payload).toBeDefined();
+      expect(result[0].description).toContain('Send');
+      expect(result[0].description).toContain('XRP');
+    });
+
+    it('should build inner transactions with payment (token)', async () => {
+      const innerTransactions = [
+        {
+          type: 'payment' as const,
+          destination: mockDestination,
+          amount: '100',
+          currency: 'USD',
+          issuer: mockIssuer,
+        },
+      ];
+
+      const result = await service.buildBatchInnerTransactions(mockAccount, innerTransactions);
+
+      expect(result[0].description).toContain('100 USD');
+    });
+
+    it('should build inner transactions with trust-set', async () => {
+      const innerTransactions = [
+        { type: 'trust-set' as const, currency: 'EUR', issuer: mockIssuer, amount: '500000' },
+      ];
+
+      const result = await service.buildBatchInnerTransactions(mockAccount, innerTransactions);
+
+      expect(result[0].description).toContain('trust line');
+      expect(result[0].description).toContain('EUR');
+    });
+
+    it('should build inner transactions with nft-mint', async () => {
+      const innerTransactions = [
+        { type: 'nft-mint' as const, uri: '697066733A2F2F', taxon: 42 },
+      ];
+
+      const result = await service.buildBatchInnerTransactions(mockAccount, innerTransactions);
+
+      expect(result[0].description).toContain('Mint NFT');
+      expect(result[0].description).toContain('42');
+    });
+
+    it('should throw error for unknown transaction type', async () => {
+      const innerTransactions = [{ type: 'invalid-type' as any }];
+
+      await expect(
+        service.buildBatchInnerTransactions(mockAccount, innerTransactions)
+      ).rejects.toThrow('Unknown transaction type');
+    });
+
+    it('should return base64 encoded payloads', async () => {
+      const innerTransactions = [
+        { type: 'payment' as const, destination: mockDestination, amount: '1000000' },
+      ];
+
+      const result = await service.buildBatchInnerTransactions(mockAccount, innerTransactions);
+
+      // Verify it's valid base64
+      expect(() => atob(result[0].payload)).not.toThrow();
+    });
+
+    it('should build multiple inner transactions', async () => {
+      const innerTransactions = [
+        { type: 'payment' as const, destination: mockDestination, amount: '1000000' },
+        { type: 'trust-set' as const, currency: 'USD', issuer: mockIssuer },
+        { type: 'nft-mint' as const, taxon: 0 },
+      ];
+
+      const result = await service.buildBatchInnerTransactions(mockAccount, innerTransactions);
+
+      expect(result).toHaveLength(3);
+      expect(result[0].description).toContain('XRP');
+      expect(result[1].description).toContain('trust line');
+      expect(result[2].description).toContain('NFT');
+    });
+  });
+
+  // ==================== SERIALIZATION ====================
+  describe('serializeTransaction', () => {
+    it('should produce valid base64 output', async () => {
+      const result = await service.buildPayment(mockAccount, mockDestination, '1000000');
+
+      // Should be valid base64
+      expect(() => atob(result)).not.toThrow();
+
+      // Should produce valid JSON when decoded
+      const decoded = atob(result);
+      expect(() => JSON.parse(decoded)).not.toThrow();
+    });
+
+    it('should preserve all transaction fields', async () => {
+      const result = await service.buildPayment(
+        mockAccount,
+        mockDestination,
+        '100',
+        true,
+        'USD',
+        mockIssuer
+      );
+
+      const tx = decodeTransaction(result);
+
+      // Verify all expected fields are present
+      expect(tx).toHaveProperty('TransactionType');
+      expect(tx).toHaveProperty('Account');
+      expect(tx).toHaveProperty('Destination');
+      expect(tx).toHaveProperty('Amount');
+    });
+  });
+});