@ledgerhq/coin-stellar 6.26.0 → 6.26.1

package/src/network/serialization.unit.test.ts

@@ -1,43 +1,46 @@
-import type { Horizon } from "@stellar/stellar-sdk";
-import type { BalanceAsset, RawOperation } from "../types";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BalanceAsset, RawOperation } from '../types'
+import type { Horizon } from '@stellar/stellar-sdk'
 import {
   BASE_RESERVE,
   MIN_BALANCE,
   getReservedBalance,
   rawOperationsToOperations,
-} from "./serialization";
+} from './serialization'
 
-const ADDR = "GBADDR";
-const OTHER_ADDR = "GBOTHER";
-const THIRD_ADDR = "GBTHIRD";
-const ACCOUNT_ID = "stellar:GBADDR";
-const TX_HASH = "txh";
-const BLOCK_HASH = "block-hash";
-const BLOCK_TIME = "2025-06-01T12:00:00Z";
-const CREATED_AT = "2025-06-01T12:00:00Z";
+const ADDR = 'GBADDR'
+const OTHER_ADDR = 'GBOTHER'
+const THIRD_ADDR = 'GBTHIRD'
+const ACCOUNT_ID = 'stellar:GBADDR'
+const TX_HASH = 'txh'
+const BLOCK_HASH = 'block-hash'
+const BLOCK_TIME = '2025-06-01T12:00:00Z'
+const CREATED_AT = '2025-06-01T12:00:00Z'
 
 type TxOverrides = Partial<{
-  ledger_attr: number;
-  fee_charged: string;
-  fee_account: string;
-  source_account_sequence: string;
-  memo_type: string;
-  memo: string | undefined;
-  ledger_hash: string;
-  ledger_closed_at: string;
-}>;
+  ledger_attr: number
+  fee_charged: string
+  fee_account: string
+  source_account_sequence: string
+  memo_type: string
+  memo: string | undefined
+  ledger_hash: string
+  ledger_closed_at: string
+}>
 
 function makeTx(overrides: TxOverrides = {}) {
   const {
     ledger_attr = 100,
-    fee_charged = "100",
+    fee_charged = '100',
     fee_account,
-    source_account_sequence = "42",
-    memo_type = "none",
+    source_account_sequence = '42',
+    memo_type = 'none',
     memo,
     ledger_hash = BLOCK_HASH,
     ledger_closed_at = BLOCK_TIME,
-  } = overrides;
+  } = overrides
 
   return {
     ledger_attr,
@@ -50,1147 +53,1147 @@ function makeTx(overrides: TxOverrides = {}) {
       hash: ledger_hash,
       closed_at: ledger_closed_at,
     }),
-  };
+  }
 }
 
 // `RawOperation.type` is constrained to a narrow union of Horizon operation type
 // literals which makes building fixtures with plain strings impractical, so we
 // accept any string and cast at the construction site.
-type RawOpInput = { type: string } & Record<string, unknown>;
+type RawOpInput = { type: string } & Record<string, unknown>
 
 function makeOp(rawOpOverrides: RawOpInput, txOverrides: TxOverrides = {}): RawOperation {
   return {
-    id: "op-1",
-    paging_token: "pt-1",
+    id: 'op-1',
+    paging_token: 'pt-1',
     source_account: ADDR,
     transaction_hash: TX_HASH,
     transaction_successful: true,
     created_at: CREATED_AT,
     transaction: jest.fn().mockResolvedValue(makeTx(txOverrides)),
     ...rawOpOverrides,
-  } as unknown as RawOperation;
+  } as unknown as RawOperation
 }
 
-describe("constants", () => {
-  it("exports BASE_RESERVE equal to 0.5 (stellar protocol base reserve in XLM)", () => {
-    expect(BASE_RESERVE).toBe(0.5);
-  });
+describe('constants', () => {
+  it('exports BASE_RESERVE equal to 0.5 (stellar protocol base reserve in XLM)', () => {
+    expect(BASE_RESERVE).toBe(0.5)
+  })
 
-  it("exports MIN_BALANCE equal to 1 (minimum stellar account balance in XLM)", () => {
-    expect(MIN_BALANCE).toBe(1);
-  });
-});
+  it('exports MIN_BALANCE equal to 1 (minimum stellar account balance in XLM)', () => {
+    expect(MIN_BALANCE).toBe(1)
+  })
+})
 
-describe("getReservedBalance", () => {
+describe('getReservedBalance', () => {
   type AccountInput = Partial<{
-    num_sponsoring: string;
-    num_sponsored: string;
-    subentry_count: number;
-    balances: Array<Partial<BalanceAsset>>;
-  }>;
+    num_sponsoring: string
+    num_sponsored: string
+    subentry_count: number
+    balances: Array<Partial<BalanceAsset>>
+  }>
 
   function makeAccount(overrides: AccountInput = {}): Horizon.ServerApi.AccountRecord {
     return {
-      num_sponsoring: "0",
-      num_sponsored: "0",
+      num_sponsoring: '0',
+      num_sponsored: '0',
       subentry_count: 0,
-      balances: [{ asset_type: "native", selling_liabilities: "0" }],
+      balances: [{ asset_type: 'native', selling_liabilities: '0' }],
       ...overrides,
-    } as unknown as Horizon.ServerApi.AccountRecord;
+    } as unknown as Horizon.ServerApi.AccountRecord
   }
 
-  it("should return 1 XLM (the minimum reserve) when account has no subentries, sponsors or liabilities", () => {
-    expect(getReservedBalance(makeAccount()).toNumber()).toBe(1);
-  });
+  it('should return 1 XLM (the minimum reserve) when account has no subentries, sponsors or liabilities', () => {
+    expect(getReservedBalance(makeAccount()).toNumber()).toBe(1)
+  })
 
-  it("should add 0.5 XLM per subentry", () => {
-    expect(getReservedBalance(makeAccount({ subentry_count: 4 })).toNumber()).toBe(3);
-  });
+  it('should add 0.5 XLM per subentry', () => {
+    expect(getReservedBalance(makeAccount({ subentry_count: 4 })).toNumber()).toBe(3)
+  })
 
-  it("should add 0.5 XLM per sponsoring entry", () => {
-    expect(getReservedBalance(makeAccount({ num_sponsoring: "2" })).toNumber()).toBe(2);
-  });
+  it('should add 0.5 XLM per sponsoring entry', () => {
+    expect(getReservedBalance(makeAccount({ num_sponsoring: '2' })).toNumber()).toBe(2)
+  })
 
-  it("should subtract 0.5 XLM per sponsored entry", () => {
+  it('should subtract 0.5 XLM per sponsored entry', () => {
     expect(
-      getReservedBalance(makeAccount({ num_sponsoring: "4", num_sponsored: "2" })).toNumber(),
-    ).toBe(2);
-  });
+      getReservedBalance(makeAccount({ num_sponsoring: '4', num_sponsored: '2' })).toNumber()
+    ).toBe(2)
+  })
 
-  it("should add native selling_liabilities on top of the entry reserve", () => {
+  it('should add native selling_liabilities on top of the entry reserve', () => {
     expect(
       getReservedBalance(
-        makeAccount({ balances: [{ asset_type: "native", selling_liabilities: "10.5" }] }),
-      ).toNumber(),
-    ).toBe(11.5);
-  });
+        makeAccount({ balances: [{ asset_type: 'native', selling_liabilities: '10.5' }] })
+      ).toNumber()
+    ).toBe(11.5)
+  })
 
-  it("should ignore non-native selling_liabilities (only the native balance contributes)", () => {
+  it('should ignore non-native selling_liabilities (only the native balance contributes)', () => {
     expect(
       getReservedBalance(
         makeAccount({
           balances: [
-            { asset_type: "credit_alphanum4", selling_liabilities: "100", asset_code: "USDC" },
-            { asset_type: "native", selling_liabilities: "2" },
+            { asset_type: 'credit_alphanum4', selling_liabilities: '100', asset_code: 'USDC' },
+            { asset_type: 'native', selling_liabilities: '2' },
           ],
-        }),
-      ).toNumber(),
-    ).toBe(3);
-  });
+        })
+      ).toNumber()
+    ).toBe(3)
+  })
 
-  it("should fall back to 0 selling_liabilities when no native balance entry exists", () => {
-    expect(getReservedBalance(makeAccount({ balances: [] })).toNumber()).toBe(1);
-  });
+  it('should fall back to 0 selling_liabilities when no native balance entry exists', () => {
+    expect(getReservedBalance(makeAccount({ balances: [] })).toNumber()).toBe(1)
+  })
 
-  it("should treat undefined selling_liabilities on the native balance as 0", () => {
+  it('should treat undefined selling_liabilities on the native balance as 0', () => {
     expect(
-      getReservedBalance(makeAccount({ balances: [{ asset_type: "native" }] })).toNumber(),
-    ).toBe(1);
-  });
+      getReservedBalance(makeAccount({ balances: [{ asset_type: 'native' }] })).toNumber()
+    ).toBe(1)
+  })
 
-  it("should combine subentries, sponsoring/sponsored entries and selling_liabilities", () => {
+  it('should combine subentries, sponsoring/sponsored entries and selling_liabilities', () => {
     // (2 + 3 + 2 - 1) * 0.5 + 4.5 = 6 * 0.5 + 4.5 = 7.5
     expect(
       getReservedBalance(
         makeAccount({
           subentry_count: 3,
-          num_sponsoring: "2",
-          num_sponsored: "1",
-          balances: [{ asset_type: "native", selling_liabilities: "4.5" }],
-        }),
-      ).toNumber(),
-    ).toBe(7.5);
-  });
-});
-
-describe("rawOperationsToOperations", () => {
-  describe("address filtering", () => {
-    it("should exclude operations not involving the address", async () => {
+          num_sponsoring: '2',
+          num_sponsored: '1',
+          balances: [{ asset_type: 'native', selling_liabilities: '4.5' }],
+        })
+      ).toNumber()
+    ).toBe(7.5)
+  })
+})
+
+describe('rawOperationsToOperations', () => {
+  describe('address filtering', () => {
+    it('should exclude operations not involving the address', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: OTHER_ADDR,
         to: THIRD_ADDR,
-        amount: "10",
+        amount: '10',
         source_account: OTHER_ADDR,
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(0);
-    });
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(0)
+    })
 
-    it("should include operations where `from` equals the address", async () => {
+    it('should include operations where `from` equals the address', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "10",
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
+        amount: '10',
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
 
-    it("should include operations where `to` equals the address", async () => {
+    it('should include operations where `to` equals the address', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "10",
+        amount: '10',
         source_account: OTHER_ADDR,
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
 
-    it("should include operations where `funder` equals the address", async () => {
+    it('should include operations where `funder` equals the address', async () => {
       const op = makeOp({
-        type: "create_account",
+        type: 'create_account',
         funder: ADDR,
         account: OTHER_ADDR,
-        starting_balance: "10",
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
+        starting_balance: '10',
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
 
-    it("should include operations where `account` equals the address", async () => {
+    it('should include operations where `account` equals the address', async () => {
       const op = makeOp({
-        type: "create_account",
+        type: 'create_account',
         funder: OTHER_ADDR,
         account: ADDR,
-        starting_balance: "10",
+        starting_balance: '10',
         source_account: OTHER_ADDR,
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
 
-    it("should include operations where `trustor` equals the address", async () => {
+    it('should include operations where `trustor` equals the address', async () => {
       const op = makeOp({
-        type: "change_trust",
+        type: 'change_trust',
         trustor: ADDR,
-        limit: "1000",
-        asset_code: "USDC",
-        asset_issuer: "GISSUER",
+        limit: '1000',
+        asset_code: 'USDC',
+        asset_issuer: 'GISSUER',
         source_account: OTHER_ADDR,
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
 
-    it("should include operations where `source_account` equals the address", async () => {
+    it('should include operations where `source_account` equals the address', async () => {
       const op = makeOp({
-        type: "change_trust",
+        type: 'change_trust',
         trustor: OTHER_ADDR,
-        limit: "1000",
-        asset_code: "USDC",
-        asset_issuer: "GISSUER",
+        limit: '1000',
+        asset_code: 'USDC',
+        asset_issuer: 'GISSUER',
         source_account: ADDR,
-      });
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
-  });
-
-  describe("operation type filtering", () => {
-    it.each(["manage_offer", "set_options", "allow_trust", "manage_data", "bump_sequence"])(
-      "should not surface a typed Operation for unsupported %s operation",
-      async type => {
+      })
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
+  })
+
+  describe('operation type filtering', () => {
+    it.each(['manage_offer', 'set_options', 'allow_trust', 'manage_data', 'bump_sequence'])(
+      'should not surface a typed Operation for unsupported %s operation',
+      async (type) => {
         const op = makeOp({
           type,
           source_account: ADDR,
-        });
-        const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+        })
+        const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
         // No typed Operation (OUT/IN/OPT_IN/...) is emitted for unsupported types
-        expect(result.find(o => o.type !== "FEES")).toBeUndefined();
-      },
-    );
+        expect(result.find((o) => o.type !== 'FEES')).toBeUndefined()
+      }
+    )
 
     it.each([
-      ["create_account", { funder: ADDR, account: OTHER_ADDR, starting_balance: "1" }],
-      ["payment", { from: ADDR, to: OTHER_ADDR, amount: "1" }],
-      ["path_payment_strict_send", { from: ADDR, to: OTHER_ADDR, amount: "1" }],
-      ["path_payment_strict_receive", { from: ADDR, to: OTHER_ADDR, amount: "1" }],
+      ['create_account', { funder: ADDR, account: OTHER_ADDR, starting_balance: '1' }],
+      ['payment', { from: ADDR, to: OTHER_ADDR, amount: '1' }],
+      ['path_payment_strict_send', { from: ADDR, to: OTHER_ADDR, amount: '1' }],
+      ['path_payment_strict_receive', { from: ADDR, to: OTHER_ADDR, amount: '1' }],
       [
-        "change_trust",
-        { trustor: ADDR, limit: "1000", asset_code: "USDC", asset_issuer: "GISSUER" },
+        'change_trust',
+        { trustor: ADDR, limit: '1000', asset_code: 'USDC', asset_issuer: 'GISSUER' },
       ],
-    ])("should include supported %s operation", async (type, extra) => {
-      const op = makeOp({ type, ...extra } as RawOpInput);
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-    });
-  });
-
-  describe("fee-only operations", () => {
+    ])('should include supported %s operation', async (type, extra) => {
+      const op = makeOp({ type, ...extra } as RawOpInput)
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+    })
+  })
+
+  describe('fee-only operations', () => {
     // Non-fee-bump Stellar transactions have `fee_account === source_account`,
     // which is what most of these fixtures model.
-    it.each(["set_options", "manage_offer", "manage_data", "bump_sequence", "allow_trust"])(
-      "emits a single FEES Operation for unsupported %s when address paid the fee",
-      async type => {
+    it.each(['set_options', 'manage_offer', 'manage_data', 'bump_sequence', 'allow_trust'])(
+      'emits a single FEES Operation for unsupported %s when address paid the fee',
+      async (type) => {
         const op = makeOp(
           { type, source_account: ADDR, transaction_hash: `tx-${type}` },
-          { fee_account: ADDR, fee_charged: "150" },
-        );
-        const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-        expect(result).toHaveLength(1);
+          { fee_account: ADDR, fee_charged: '150' }
+        )
+        const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+        expect(result).toHaveLength(1)
         expect(result[0]).toMatchObject({
-          type: "FEES",
+          type: 'FEES',
           value: 0n,
-          asset: { type: "native" },
+          asset: { type: 'native' },
           senders: [ADDR],
           recipients: [],
           tx: { hash: `tx-${type}`, fees: 150n, feesPayer: ADDR, failed: false },
-        });
-        expect(result[0].details).toMatchObject({ ledgerOpType: "FEES" });
-        expect(result[0].id).toBe(`${ACCOUNT_ID}-tx-${type}-FEES`);
-      },
-    );
+        })
+        expect(result[0].details).toMatchObject({ ledgerOpType: 'FEES' })
+        expect(result[0].id).toBe(`${ACCOUNT_ID}-tx-${type}-FEES`)
+      }
+    )
 
-    it("emits a FEES Operation for create_claimable_balance when address is the sponsor", async () => {
+    it('emits a FEES Operation for create_claimable_balance when address is the sponsor', async () => {
       const op = makeOp(
         {
-          type: "create_claimable_balance",
+          type: 'create_claimable_balance',
           source_account: ADDR,
-          asset: "USDC:GISSUER",
-          amount: "100",
+          asset: 'USDC:GISSUER',
+          amount: '100',
           sponsor: ADDR,
-          transaction_hash: "tx-ccb",
+          transaction_hash: 'tx-ccb',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("FEES");
-      expect(out.tx.fees).toBe(100n);
+        { fee_account: ADDR, fee_charged: '100' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('FEES')
+      expect(out.tx.fees).toBe(100n)
       // The token amount locked in the claimable balance is intentionally NOT
       // exposed on the FEES op; only the XLM fee deduction is.
-      expect(out.value).toBe(0n);
-      expect(out.asset).toEqual({ type: "native" });
-    });
+      expect(out.value).toBe(0n)
+      expect(out.asset).toEqual({ type: 'native' })
+    })
 
-    it("does NOT emit a FEES Operation when address is not the fee payer (fee-bump or unrelated)", async () => {
+    it('does NOT emit a FEES Operation when address is not the fee payer (fee-bump or unrelated)', async () => {
       const op = makeOp(
         {
-          type: "set_options",
+          type: 'set_options',
           source_account: ADDR,
-          transaction_hash: "tx-fee-bumped",
+          transaction_hash: 'tx-fee-bumped',
         },
         // fee bumped by another account
-        { fee_account: OTHER_ADDR, fee_charged: "150" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(0);
-    });
+        { fee_account: OTHER_ADDR, fee_charged: '150' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(0)
+    })
 
-    it("does NOT emit a FEES Operation when the tx already has a surfaced Operation (avoids double-counting)", async () => {
+    it('does NOT emit a FEES Operation when the tx already has a surfaced Operation (avoids double-counting)', async () => {
       // Multi-op transaction: one supported (change_trust, OPT_IN) + one
       // unsupported (set_options). Only the supported op is surfaced; the
       // unsupported one does not produce an extra FEES row since the tx fee is
       // already carried on the OPT_IN op's `tx.fees`.
       const supportedOp = makeOp(
         {
-          type: "change_trust",
+          type: 'change_trust',
           trustor: ADDR,
-          limit: "1000",
-          asset_code: "BTC",
-          asset_issuer: "GISSUER",
+          limit: '1000',
+          asset_code: 'BTC',
+          asset_issuer: 'GISSUER',
           source_account: ADDR,
-          transaction_hash: "tx-mixed",
-          id: "op-1",
-          paging_token: "pt-1",
+          transaction_hash: 'tx-mixed',
+          id: 'op-1',
+          paging_token: 'pt-1',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
+        { fee_account: ADDR, fee_charged: '100' }
+      )
       const unsupportedOp = makeOp(
         {
-          type: "set_options",
+          type: 'set_options',
           source_account: ADDR,
-          transaction_hash: "tx-mixed",
-          id: "op-2",
-          paging_token: "pt-2",
+          transaction_hash: 'tx-mixed',
+          id: 'op-2',
+          paging_token: 'pt-2',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
+        { fee_account: ADDR, fee_charged: '100' }
+      )
       const result = await rawOperationsToOperations(
         [supportedOp, unsupportedOp],
         ADDR,
         ACCOUNT_ID,
-        0,
-      );
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe("OPT_IN");
-      expect(result[0].tx.fees).toBe(100n);
-    });
-
-    it("emits a single FEES Operation per tx even when multiple unsupported ops share the same tx hash", async () => {
+        0
+      )
+      expect(result).toHaveLength(1)
+      expect(result[0].type).toBe('OPT_IN')
+      expect(result[0].tx.fees).toBe(100n)
+    })
+
+    it('emits a single FEES Operation per tx even when multiple unsupported ops share the same tx hash', async () => {
       const opA = makeOp(
         {
-          type: "set_options",
+          type: 'set_options',
           source_account: ADDR,
-          transaction_hash: "tx-multi",
-          id: "op-a",
-          paging_token: "pt-a",
+          transaction_hash: 'tx-multi',
+          id: 'op-a',
+          paging_token: 'pt-a',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
+        { fee_account: ADDR, fee_charged: '100' }
+      )
       const opB = makeOp(
         {
-          type: "manage_data",
+          type: 'manage_data',
           source_account: ADDR,
-          transaction_hash: "tx-multi",
-          id: "op-b",
-          paging_token: "pt-b",
+          transaction_hash: 'tx-multi',
+          id: 'op-b',
+          paging_token: 'pt-b',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
-      const result = await rawOperationsToOperations([opA, opB], ADDR, ACCOUNT_ID, 0);
-      expect(result).toHaveLength(1);
-      expect(result[0].type).toBe("FEES");
-      expect(result[0].tx.hash).toBe("tx-multi");
+        { fee_account: ADDR, fee_charged: '100' }
+      )
+      const result = await rawOperationsToOperations([opA, opB], ADDR, ACCOUNT_ID, 0)
+      expect(result).toHaveLength(1)
+      expect(result[0].type).toBe('FEES')
+      expect(result[0].tx.hash).toBe('tx-multi')
       // The FEES op anchors at the first raw op's index/pagingToken so the
       // descending Horizon page order is preserved.
-      expect(result[0].details).toMatchObject({ index: "op-a", pagingToken: "pt-a" });
-    });
+      expect(result[0].details).toMatchObject({ index: 'op-a', pagingToken: 'pt-a' })
+    })
 
-    it("honors minHeight for fee-only operations", async () => {
+    it('honors minHeight for fee-only operations', async () => {
       const op = makeOp(
-        { type: "set_options", source_account: ADDR },
-        { fee_account: ADDR, fee_charged: "100", ledger_attr: 99 },
-      );
-      expect(await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 100)).toHaveLength(0);
-    });
+        { type: 'set_options', source_account: ADDR },
+        { fee_account: ADDR, fee_charged: '100', ledger_attr: 99 }
+      )
+      expect(await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 100)).toHaveLength(0)
+    })
 
-    it("marks the FEES Operation as failed when the transaction failed", async () => {
+    it('marks the FEES Operation as failed when the transaction failed', async () => {
       const op = makeOp(
         {
-          type: "set_options",
+          type: 'set_options',
           source_account: ADDR,
           transaction_successful: false,
-          transaction_hash: "tx-failed",
+          transaction_hash: 'tx-failed',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("FEES");
-      expect(out.tx.failed).toBe(true);
-      expect(out.tx.fees).toBe(100n);
-    });
-  });
-
-  describe("minHeight filtering", () => {
-    it("should exclude operations from blocks strictly below minHeight", async () => {
+        { fee_account: ADDR, fee_charged: '100' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('FEES')
+      expect(out.tx.failed).toBe(true)
+      expect(out.tx.fees).toBe(100n)
+    })
+  })
+
+  describe('minHeight filtering', () => {
+    it('should exclude operations from blocks strictly below minHeight', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "5" },
-        { ledger_attr: 99 },
-      );
-      expect(await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 100)).toHaveLength(0);
-    });
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '5' },
+        { ledger_attr: 99 }
+      )
+      expect(await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 100)).toHaveLength(0)
+    })
 
-    it("should include operations at minHeight", async () => {
+    it('should include operations at minHeight', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "5" },
-        { ledger_attr: 100 },
-      );
-      expect(await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 100)).toHaveLength(1);
-    });
-  });
-
-  describe("operation type determination", () => {
-    it("should mark create_account as OUT when funder is the address", async () => {
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '5' },
+        { ledger_attr: 100 }
+      )
+      expect(await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 100)).toHaveLength(1)
+    })
+  })
+
+  describe('operation type determination', () => {
+    it('should mark create_account as OUT when funder is the address', async () => {
       const op = makeOp({
-        type: "create_account",
+        type: 'create_account',
         funder: ADDR,
         account: OTHER_ADDR,
-        starting_balance: "10",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OUT");
-    });
+        starting_balance: '10',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OUT')
+    })
 
-    it("should mark create_account as IN when account is the address", async () => {
+    it('should mark create_account as IN when account is the address', async () => {
       const op = makeOp({
-        type: "create_account",
+        type: 'create_account',
         funder: OTHER_ADDR,
         account: ADDR,
-        starting_balance: "10",
+        starting_balance: '10',
         source_account: OTHER_ADDR,
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("IN");
-    });
-
-    it("should mark payment as OUT when from is the address and recipient differs", async () => {
-      const op = makeOp({ type: "payment", from: ADDR, to: OTHER_ADDR, amount: "5" });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OUT");
-    });
-
-    it("should mark payment as IN when the address is the recipient", async () => {
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('IN')
+    })
+
+    it('should mark payment as OUT when from is the address and recipient differs', async () => {
+      const op = makeOp({ type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '5' })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OUT')
+    })
+
+    it('should mark payment as IN when the address is the recipient', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "5",
+        amount: '5',
         source_account: OTHER_ADDR,
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("IN");
-    });
-
-    it("should mark self-payments (from=to=address) as IN", async () => {
-      const op = makeOp({ type: "payment", from: ADDR, to: ADDR, amount: "5" });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("IN");
-    });
-
-    it("should mark path_payment_strict_send as OUT when address is not the recipient", async () => {
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('IN')
+    })
+
+    it('should mark self-payments (from=to=address) as IN', async () => {
+      const op = makeOp({ type: 'payment', from: ADDR, to: ADDR, amount: '5' })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('IN')
+    })
+
+    it('should mark path_payment_strict_send as OUT when address is not the recipient', async () => {
       const op = makeOp({
-        type: "path_payment_strict_send",
+        type: 'path_payment_strict_send',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "5",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OUT");
-    });
+        amount: '5',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OUT')
+    })
 
-    it("should mark path_payment_strict_send as IN when address is the recipient", async () => {
+    it('should mark path_payment_strict_send as IN when address is the recipient', async () => {
       const op = makeOp({
-        type: "path_payment_strict_send",
+        type: 'path_payment_strict_send',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "5",
+        amount: '5',
         source_account: OTHER_ADDR,
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("IN");
-    });
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('IN')
+    })
 
-    it("should mark path_payment_strict_receive as OUT when address is the source", async () => {
+    it('should mark path_payment_strict_receive as OUT when address is the source', async () => {
       const op = makeOp({
-        type: "path_payment_strict_receive",
+        type: 'path_payment_strict_receive',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "5",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OUT");
-    });
+        amount: '5',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OUT')
+    })
 
-    it("should mark path_payment_strict_receive as IN when address is the recipient", async () => {
+    it('should mark path_payment_strict_receive as IN when address is the recipient', async () => {
       const op = makeOp({
-        type: "path_payment_strict_receive",
+        type: 'path_payment_strict_receive',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "5",
+        amount: '5',
         source_account: OTHER_ADDR,
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("IN");
-    });
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('IN')
+    })
 
-    it("should mark change_trust as OPT_IN when limit is non-zero", async () => {
+    it('should mark change_trust as OPT_IN when limit is non-zero', async () => {
       const op = makeOp({
-        type: "change_trust",
+        type: 'change_trust',
         trustor: ADDR,
-        limit: "1000",
-        asset_code: "USDC",
-        asset_issuer: "GISSUER",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OPT_IN");
-    });
-
-    it("should mark change_trust as OPT_OUT when limit is zero", async () => {
+        limit: '1000',
+        asset_code: 'USDC',
+        asset_issuer: 'GISSUER',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OPT_IN')
+    })
+
+    it('should mark change_trust as OPT_OUT when limit is zero', async () => {
       const op = makeOp({
-        type: "change_trust",
+        type: 'change_trust',
         trustor: ADDR,
-        limit: "0",
-        asset_code: "USDC",
-        asset_issuer: "GISSUER",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OPT_OUT");
-    });
-  });
-
-  describe("memo handling", () => {
+        limit: '0',
+        asset_code: 'USDC',
+        asset_issuer: 'GISSUER',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OPT_OUT')
+    })
+  })
+
+  describe('memo handling', () => {
     it("should set NO_MEMO when memo_type is 'none'", async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { memo_type: "none" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.details).toMatchObject({ memo: { type: "NO_MEMO" } });
-    });
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { memo_type: 'none' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.details).toMatchObject({ memo: { type: 'NO_MEMO' } })
+    })
 
     it("should set MEMO_ID with raw memo when memo_type is 'id'", async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { memo_type: "id", memo: "12345" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.details).toMatchObject({ memo: { type: "MEMO_ID", value: "12345" } });
-    });
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { memo_type: 'id', memo: '12345' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.details).toMatchObject({ memo: { type: 'MEMO_ID', value: '12345' } })
+    })
 
     it("should set MEMO_TEXT with raw memo when memo_type is 'text'", async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { memo_type: "text", memo: "hello" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.details).toMatchObject({ memo: { type: "MEMO_TEXT", value: "hello" } });
-    });
-
-    it("should convert MEMO_RETURN from base64 to hex", async () => {
-      const memoBase64 = Buffer.from("deadbeef", "hex").toString("base64");
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { memo_type: 'text', memo: 'hello' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.details).toMatchObject({ memo: { type: 'MEMO_TEXT', value: 'hello' } })
+    })
+
+    it('should convert MEMO_RETURN from base64 to hex', async () => {
+      const memoBase64 = Buffer.from('deadbeef', 'hex').toString('base64')
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { memo_type: "return", memo: memoBase64 },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { memo_type: 'return', memo: memoBase64 }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
       expect(out.details).toMatchObject({
-        memo: { type: "MEMO_RETURN", value: "deadbeef" },
-      });
-    });
+        memo: { type: 'MEMO_RETURN', value: 'deadbeef' },
+      })
+    })
 
-    it("should convert MEMO_HASH from base64 to hex", async () => {
-      const memoBase64 = Buffer.from("cafebabe", "hex").toString("base64");
+    it('should convert MEMO_HASH from base64 to hex', async () => {
+      const memoBase64 = Buffer.from('cafebabe', 'hex').toString('base64')
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { memo_type: "hash", memo: memoBase64 },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { memo_type: 'hash', memo: memoBase64 }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
       expect(out.details).toMatchObject({
-        memo: { type: "MEMO_HASH", value: "cafebabe" },
-      });
-    });
+        memo: { type: 'MEMO_HASH', value: 'cafebabe' },
+      })
+    })
 
-    it("should leave memo undefined when memo_type is set but memo value is missing", async () => {
+    it('should leave memo undefined when memo_type is set but memo value is missing', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { memo_type: "id", memo: undefined },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect((out.details as { memo?: unknown }).memo).toBeUndefined();
-    });
-  });
-
-  describe("asset and value handling", () => {
-    it("should set native asset and value=amount*10^7 for native payments", async () => {
-      const op = makeOp({ type: "payment", from: ADDR, to: OTHER_ADDR, amount: "10" });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.asset).toEqual({ type: "native" });
-      expect(out.value).toBe(100000000n);
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { memo_type: 'id', memo: undefined }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect((out.details as { memo?: unknown }).memo).toBeUndefined()
+    })
+  })
+
+  describe('asset and value handling', () => {
+    it('should set native asset and value=amount*10^7 for native payments', async () => {
+      const op = makeOp({ type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '10' })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.asset).toEqual({ type: 'native' })
+      expect(out.value).toBe(100000000n)
       expect(out.details).toMatchObject({
         assetCode: undefined,
         assetIssuer: undefined,
         assetAmount: undefined,
-      });
-    });
+      })
+    })
 
-    it("should set token asset, NONE type and value=fee_charged when asset_code+asset_issuer are present", async () => {
+    it('should set token asset, NONE type and value=fee_charged when asset_code+asset_issuer are present', async () => {
       const op = makeOp(
         {
-          type: "payment",
+          type: 'payment',
           from: ADDR,
           to: OTHER_ADDR,
-          amount: "10",
-          asset_code: "USDC",
-          asset_issuer: "GISSUER",
+          amount: '10',
+          asset_code: 'USDC',
+          asset_issuer: 'GISSUER',
         },
-        { fee_charged: "200" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+        { fee_charged: '200' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
       expect(out.asset).toEqual({
-        type: "token",
-        assetReference: "USDC",
-        assetOwner: "GISSUER",
-      });
-      expect(out.value).toBe(200n);
-      expect(out.type).toBe("NONE");
+        type: 'token',
+        assetReference: 'USDC',
+        assetOwner: 'GISSUER',
+      })
+      expect(out.value).toBe(200n)
+      expect(out.type).toBe('NONE')
       expect(out.details).toMatchObject({
-        assetCode: "USDC",
-        assetIssuer: "GISSUER",
-        assetAmount: "100000000",
-      });
-    });
+        assetCode: 'USDC',
+        assetIssuer: 'GISSUER',
+        assetAmount: '100000000',
+      })
+    })
 
-    it("should fall back to native asset when asset_code is set but asset_issuer is missing", async () => {
+    it('should fall back to native asset when asset_code is set but asset_issuer is missing', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "10",
-        asset_code: "USDC",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.asset).toEqual({ type: "native" });
-    });
-
-    it("should preserve OPT_IN/OPT_OUT type for token change_trust operations", async () => {
+        amount: '10',
+        asset_code: 'USDC',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.asset).toEqual({ type: 'native' })
+    })
+
+    it('should preserve OPT_IN/OPT_OUT type for token change_trust operations', async () => {
       const op = makeOp({
-        type: "change_trust",
+        type: 'change_trust',
         trustor: ADDR,
-        limit: "1000",
-        asset_code: "USDC",
-        asset_issuer: "GISSUER",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("OPT_IN");
-    });
-
-    it("should parse create_account starting_balance through the stellar unit (10^7)", async () => {
+        limit: '1000',
+        asset_code: 'USDC',
+        asset_issuer: 'GISSUER',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('OPT_IN')
+    })
+
+    it('should parse create_account starting_balance through the stellar unit (10^7)', async () => {
       const op = makeOp({
-        type: "create_account",
+        type: 'create_account',
         funder: ADDR,
         account: OTHER_ADDR,
-        starting_balance: "2.5",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.value).toBe(25000000n);
-    });
-  });
-
-  describe("path_payment_strict_send native source side", () => {
-    it("emits a native OUT row using source_amount when address is the source and source asset is native", async () => {
+        starting_balance: '2.5',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.value).toBe(25000000n)
+    })
+  })
+
+  describe('path_payment_strict_send native source side', () => {
+    it('emits a native OUT row using source_amount when address is the source and source asset is native', async () => {
       const op = makeOp(
         {
-          type: "path_payment_strict_send",
+          type: 'path_payment_strict_send',
           from: ADDR,
           to: OTHER_ADDR,
           source_account: ADDR,
-          source_asset_type: "native",
-          source_amount: "0.7920000",
-          asset_type: "credit_alphanum12",
-          asset_code: "SPDX",
-          asset_issuer: "GISSUER",
-          amount: "1234.5678901",
+          source_asset_type: 'native',
+          source_amount: '0.7920000',
+          asset_type: 'credit_alphanum12',
+          asset_code: 'SPDX',
+          asset_issuer: 'GISSUER',
+          amount: '1234.5678901',
         },
-        { fee_charged: "100" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+        { fee_charged: '100' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
       // No FEES row: native OUT already carries the fee on `tx.fees`.
-      expect(result.map(o => `${o.type}:${o.asset.type}`)).toEqual(["OUT:native"]);
+      expect(result.map((o) => `${o.type}:${o.asset.type}`)).toEqual(['OUT:native'])
       expect(result[0]).toMatchObject({
-        type: "OUT",
-        asset: { type: "native" },
+        type: 'OUT',
+        asset: { type: 'native' },
         value: 7920000n,
         senders: [ADDR],
         recipients: [OTHER_ADDR],
         tx: { fees: 100n },
-      });
-    });
+      })
+    })
 
-    it("emits a native IN row using `amount` when address is the destination and dest asset is native", async () => {
+    it('emits a native IN row using `amount` when address is the destination and dest asset is native', async () => {
       const op = makeOp(
         {
-          type: "path_payment_strict_send",
+          type: 'path_payment_strict_send',
           from: OTHER_ADDR,
           to: ADDR,
           source_account: OTHER_ADDR,
-          source_asset_type: "credit_alphanum4",
-          source_asset_code: "USDC",
-          source_asset_issuer: "GISSUER",
-          source_amount: "10.0000000",
-          asset_type: "native",
-          amount: "9.9000000",
+          source_asset_type: 'credit_alphanum4',
+          source_asset_code: 'USDC',
+          source_asset_issuer: 'GISSUER',
+          source_amount: '10.0000000',
+          asset_type: 'native',
+          amount: '9.9000000',
         },
-        { fee_charged: "100" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+        { fee_charged: '100' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
       expect(result).toEqual([
         expect.objectContaining({
-          type: "IN",
-          asset: { type: "native" },
+          type: 'IN',
+          asset: { type: 'native' },
           value: 99000000n,
           senders: [OTHER_ADDR],
           recipients: [ADDR],
         }),
-      ]);
-    });
+      ])
+    })
 
-    it("emits a token NONE row when the source asset is a token and address is the source", async () => {
+    it('emits a token NONE row when the source asset is a token and address is the source', async () => {
       const op = makeOp(
         {
-          type: "path_payment_strict_send",
+          type: 'path_payment_strict_send',
           from: ADDR,
           to: OTHER_ADDR,
           source_account: ADDR,
-          source_asset_type: "credit_alphanum4",
-          source_asset_code: "USDC",
-          source_asset_issuer: "GISSUER",
-          source_amount: "5.0000000",
-          asset_type: "credit_alphanum4",
-          asset_code: "EURC",
-          asset_issuer: "GISSUER2",
-          amount: "4.5000000",
+          source_asset_type: 'credit_alphanum4',
+          source_asset_code: 'USDC',
+          source_asset_issuer: 'GISSUER',
+          source_amount: '5.0000000',
+          asset_type: 'credit_alphanum4',
+          asset_code: 'EURC',
+          asset_issuer: 'GISSUER2',
+          amount: '4.5000000',
         },
-        { fee_charged: "300" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.type).toBe("NONE");
+        { fee_charged: '300' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.type).toBe('NONE')
       expect(out.asset).toEqual({
-        type: "token",
-        assetReference: "USDC",
-        assetOwner: "GISSUER",
-      });
+        type: 'token',
+        assetReference: 'USDC',
+        assetOwner: 'GISSUER',
+      })
       // legacy convention: NONE token rows carry `value = fee_charged` and the
       // real token amount on `details.assetAmount`.
-      expect(out.value).toBe(300n);
+      expect(out.value).toBe(300n)
       expect(out.details).toMatchObject({
-        assetCode: "USDC",
-        assetIssuer: "GISSUER",
-        assetAmount: "50000000",
-        ledgerOpType: "NONE",
-      });
-    });
-
-    it("emits both a native OUT (source) and a token NONE (dest) row for self-swaps", async () => {
+        assetCode: 'USDC',
+        assetIssuer: 'GISSUER',
+        assetAmount: '50000000',
+        ledgerOpType: 'NONE',
+      })
+    })
+
+    it('emits both a native OUT (source) and a token NONE (dest) row for self-swaps', async () => {
       const op = makeOp(
         {
-          type: "path_payment_strict_send",
+          type: 'path_payment_strict_send',
           from: ADDR,
           to: ADDR,
           source_account: ADDR,
-          source_asset_type: "native",
-          source_amount: "0.7920000",
-          asset_type: "credit_alphanum12",
-          asset_code: "SPDX",
-          asset_issuer: "GISSUER",
-          amount: "1234.5678901",
-          id: "op-self-swap",
+          source_asset_type: 'native',
+          source_amount: '0.7920000',
+          asset_type: 'credit_alphanum12',
+          asset_code: 'SPDX',
+          asset_issuer: 'GISSUER',
+          amount: '1234.5678901',
+          id: 'op-self-swap',
         },
-        { fee_charged: "4580" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result.map(o => `${o.type}:${o.asset.type}`)).toEqual(["OUT:native", "NONE:token"]);
-      expect(result.map(o => (o.details as { index: string }).index)).toEqual([
-        "op-self-swap-OUT-NATIVE",
-        "op-self-swap-IN-TOKEN-SPDX",
-      ]);
-      expect(result[0]).toMatchObject({ value: 7920000n, senders: [ADDR], recipients: [ADDR] });
+        { fee_charged: '4580' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result.map((o) => `${o.type}:${o.asset.type}`)).toEqual(['OUT:native', 'NONE:token'])
+      expect(result.map((o) => (o.details as { index: string }).index)).toEqual([
+        'op-self-swap-OUT-NATIVE',
+        'op-self-swap-IN-TOKEN-SPDX',
+      ])
+      expect(result[0]).toMatchObject({ value: 7920000n, senders: [ADDR], recipients: [ADDR] })
       expect(result[1]).toMatchObject({
         value: 4580n,
-        details: { assetAmount: "12345678901" },
-      });
-    });
-  });
+        details: { assetAmount: '12345678901' },
+      })
+    })
+  })
 
-  describe("liquidity_pool_deposit", () => {
-    it("emits a native OUT row using reserves_deposited when one of the reserves is native", async () => {
+  describe('liquidity_pool_deposit', () => {
+    it('emits a native OUT row using reserves_deposited when one of the reserves is native', async () => {
       const op = makeOp(
         {
-          type: "liquidity_pool_deposit",
+          type: 'liquidity_pool_deposit',
           source_account: ADDR,
-          liquidity_pool_id: "pool-id",
+          liquidity_pool_id: 'pool-id',
           reserves_deposited: [
-            { asset: "native", amount: "10.0000000" },
-            { asset: "SPDX:GISSUER", amount: "57173830.2052035" },
+            { asset: 'native', amount: '10.0000000' },
+            { asset: 'SPDX:GISSUER', amount: '57173830.2052035' },
           ],
-          shares_received: "23909.3448196",
-          id: "op-lp-deposit",
+          shares_received: '23909.3448196',
+          id: 'op-lp-deposit',
         },
-        { fee_charged: "100" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result.map(o => `${o.type}:${o.asset.type}`)).toEqual(["OUT:native", "NONE:token"]);
+        { fee_charged: '100' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result.map((o) => `${o.type}:${o.asset.type}`)).toEqual(['OUT:native', 'NONE:token'])
       expect(result[0]).toMatchObject({
-        type: "OUT",
-        asset: { type: "native" },
+        type: 'OUT',
+        asset: { type: 'native' },
         value: 100000000n,
         tx: { fees: 100n },
-      });
+      })
       // Token leg: legacy NONE convention with the deposited token amount on
       // `details.assetAmount`.
       expect(result[1]).toMatchObject({
-        type: "NONE",
-        asset: { type: "token", assetReference: "SPDX", assetOwner: "GISSUER" },
+        type: 'NONE',
+        asset: { type: 'token', assetReference: 'SPDX', assetOwner: 'GISSUER' },
         value: 100n,
-        details: { assetAmount: "571738302052035" },
-      });
-      expect(result.map(o => (o.details as { index: string }).index)).toEqual([
-        "op-lp-deposit-NATIVE",
-        "op-lp-deposit-TOKEN-SPDX",
-      ]);
-    });
-
-    it("does NOT emit a duplicate FEES row when liquidity_pool_deposit is surfaced", async () => {
+        details: { assetAmount: '571738302052035' },
+      })
+      expect(result.map((o) => (o.details as { index: string }).index)).toEqual([
+        'op-lp-deposit-NATIVE',
+        'op-lp-deposit-TOKEN-SPDX',
+      ])
+    })
+
+    it('does NOT emit a duplicate FEES row when liquidity_pool_deposit is surfaced', async () => {
       const op = makeOp(
         {
-          type: "liquidity_pool_deposit",
+          type: 'liquidity_pool_deposit',
           source_account: ADDR,
-          liquidity_pool_id: "pool-id",
+          liquidity_pool_id: 'pool-id',
           reserves_deposited: [
-            { asset: "native", amount: "10.0000000" },
-            { asset: "SPDX:GISSUER", amount: "57173830.2052035" },
+            { asset: 'native', amount: '10.0000000' },
+            { asset: 'SPDX:GISSUER', amount: '57173830.2052035' },
           ],
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result.map(o => o.type)).toEqual(["OUT", "NONE"]);
-      expect(result.find(o => o.type === "FEES")).toBeUndefined();
-    });
-  });
-
-  describe("liquidity_pool_withdraw", () => {
-    it("emits a native IN row using reserves_received when one of the reserves is native", async () => {
+        { fee_account: ADDR, fee_charged: '100' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result.map((o) => o.type)).toEqual(['OUT', 'NONE'])
+      expect(result.find((o) => o.type === 'FEES')).toBeUndefined()
+    })
+  })
+
+  describe('liquidity_pool_withdraw', () => {
+    it('emits a native IN row using reserves_received when one of the reserves is native', async () => {
       const op = makeOp(
         {
-          type: "liquidity_pool_withdraw",
+          type: 'liquidity_pool_withdraw',
           source_account: ADDR,
-          liquidity_pool_id: "pool-id",
+          liquidity_pool_id: 'pool-id',
           reserves_received: [
-            { asset: "native", amount: "26.6614878" },
-            { asset: "SPDX:GISSUER", amount: "152433937.6498273" },
+            { asset: 'native', amount: '26.6614878' },
+            { asset: 'SPDX:GISSUER', amount: '152433937.6498273' },
           ],
-          shares: "63745.8705215",
-          id: "op-lp-withdraw",
+          shares: '63745.8705215',
+          id: 'op-lp-withdraw',
         },
-        { fee_charged: "100" },
-      );
-      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(result.map(o => `${o.type}:${o.asset.type}`)).toEqual(["IN:native", "NONE:token"]);
+        { fee_charged: '100' }
+      )
+      const result = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(result.map((o) => `${o.type}:${o.asset.type}`)).toEqual(['IN:native', 'NONE:token'])
       expect(result[0]).toMatchObject({
-        type: "IN",
-        asset: { type: "native" },
+        type: 'IN',
+        asset: { type: 'native' },
         value: 266614878n,
         senders: [ADDR],
-      });
-    });
-  });
+      })
+    })
+  })
 
-  describe("failed transactions", () => {
-    it("should set value=0 for IN ops when transaction failed", async () => {
+  describe('failed transactions', () => {
+    it('should set value=0 for IN ops when transaction failed', async () => {
       const op = makeOp(
         {
-          type: "payment",
+          type: 'payment',
           from: OTHER_ADDR,
           to: ADDR,
-          amount: "10",
+          amount: '10',
           source_account: OTHER_ADDR,
           transaction_successful: false,
         },
-        { fee_charged: "150" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.value).toBe(0n);
-      expect(out.tx.failed).toBe(true);
-    });
-
-    it("should set value=fee_charged for OUT ops when transaction failed", async () => {
+        { fee_charged: '150' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.value).toBe(0n)
+      expect(out.tx.failed).toBe(true)
+    })
+
+    it('should set value=fee_charged for OUT ops when transaction failed', async () => {
       const op = makeOp(
         {
-          type: "payment",
+          type: 'payment',
           from: ADDR,
           to: OTHER_ADDR,
-          amount: "10",
+          amount: '10',
           transaction_successful: false,
         },
-        { fee_charged: "150" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.value).toBe(150n);
-      expect(out.tx.failed).toBe(true);
-    });
-  });
-
-  describe("recipients", () => {
-    it("should use to_muxed for payment when present", async () => {
+        { fee_charged: '150' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.value).toBe(150n)
+      expect(out.tx.failed).toBe(true)
+    })
+  })
+
+  describe('recipients', () => {
+    it('should use to_muxed for payment when present', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        to_muxed: "MMUXED",
-        amount: "10",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.recipients).toEqual(["MMUXED"]);
-    });
-
-    it("should fall back to `to` for payment when no to_muxed is set", async () => {
-      const op = makeOp({ type: "payment", from: ADDR, to: OTHER_ADDR, amount: "10" });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.recipients).toEqual([OTHER_ADDR]);
-    });
-
-    it("should use `account` for create_account recipients", async () => {
+        to_muxed: 'MMUXED',
+        amount: '10',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.recipients).toEqual(['MMUXED'])
+    })
+
+    it('should fall back to `to` for payment when no to_muxed is set', async () => {
+      const op = makeOp({ type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '10' })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.recipients).toEqual([OTHER_ADDR])
+    })
+
+    it('should use `account` for create_account recipients', async () => {
       const op = makeOp({
-        type: "create_account",
+        type: 'create_account',
         funder: ADDR,
         account: OTHER_ADDR,
-        starting_balance: "10",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.recipients).toEqual([OTHER_ADDR]);
-    });
+        starting_balance: '10',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.recipients).toEqual([OTHER_ADDR])
+    })
 
-    it("should use `to` for path_payment_strict_send recipients", async () => {
+    it('should use `to` for path_payment_strict_send recipients', async () => {
       const op = makeOp({
-        type: "path_payment_strict_send",
+        type: 'path_payment_strict_send',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "10",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.recipients).toEqual([OTHER_ADDR]);
-    });
+        amount: '10',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.recipients).toEqual([OTHER_ADDR])
+    })
 
-    it("should return empty recipients for change_trust", async () => {
+    it('should return empty recipients for change_trust', async () => {
       const op = makeOp({
-        type: "change_trust",
+        type: 'change_trust',
         trustor: ADDR,
-        limit: "1000",
-        asset_code: "USDC",
-        asset_issuer: "GISSUER",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.recipients).toEqual([]);
-    });
-
-    it("should return empty recipients for path_payment_strict_receive", async () => {
+        limit: '1000',
+        asset_code: 'USDC',
+        asset_issuer: 'GISSUER',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.recipients).toEqual([])
+    })
+
+    it('should return empty recipients for path_payment_strict_receive', async () => {
       const op = makeOp({
-        type: "path_payment_strict_receive",
+        type: 'path_payment_strict_receive',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "10",
+        amount: '10',
         source_account: OTHER_ADDR,
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.recipients).toEqual([ADDR]);
-    });
-  });
-
-  describe("sequence handling", () => {
-    it("should expose source_account_sequence as a string when it is a number", async () => {
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.recipients).toEqual([ADDR])
+    })
+  })
+
+  describe('sequence handling', () => {
+    it('should expose source_account_sequence as a string when it is a number', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { source_account_sequence: "123456789" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.details).toMatchObject({ sequence: "123456789" });
-    });
-
-    it("should expose sequence as undefined when source_account_sequence is not numeric", async () => {
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { source_account_sequence: '123456789' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.details).toMatchObject({ sequence: '123456789' })
+    })
+
+    it('should expose sequence as undefined when source_account_sequence is not numeric', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { source_account_sequence: "not-a-number" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect((out.details as { sequence?: string }).sequence).toBeUndefined();
-    });
-  });
-
-  describe("transaction metadata", () => {
-    it("should expose fee_account as feesPayer when present (fee bump transactions)", async () => {
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { source_account_sequence: 'not-a-number' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect((out.details as { sequence?: string }).sequence).toBeUndefined()
+    })
+  })
+
+  describe('transaction metadata', () => {
+    it('should expose fee_account as feesPayer when present (fee bump transactions)', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
-        { fee_account: "GSPONSOR", fee_charged: "500" },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.tx.feesPayer).toBe("GSPONSOR");
-      expect(out.tx.fees).toBe(500n);
-    });
-
-    it("should omit feesPayer when fee_account is not set", async () => {
-      const op = makeOp({ type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect("feesPayer" in out.tx).toBe(false);
-    });
-
-    it("should build the operation id as `${accountId}-${transactionHash}-${type}`", async () => {
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
+        { fee_account: 'GSPONSOR', fee_charged: '500' }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.tx.feesPayer).toBe('GSPONSOR')
+      expect(out.tx.fees).toBe(500n)
+    })
+
+    it('should omit feesPayer when fee_account is not set', async () => {
+      const op = makeOp({ type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect('feesPayer' in out.tx).toBe(false)
+    })
+
+    it('should build the operation id as `${accountId}-${transactionHash}-${type}`', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "1",
-        transaction_hash: "my-tx-hash",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.id).toBe(`${ACCOUNT_ID}-my-tx-hash-OUT`);
-    });
-
-    it("should populate block metadata from the ledger record", async () => {
+        amount: '1',
+        transaction_hash: 'my-tx-hash',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.id).toBe(`${ACCOUNT_ID}-my-tx-hash-OUT`)
+    })
+
+    it('should populate block metadata from the ledger record', async () => {
       const op = makeOp(
-        { type: "payment", from: ADDR, to: OTHER_ADDR, amount: "1" },
+        { type: 'payment', from: ADDR, to: OTHER_ADDR, amount: '1' },
         {
           ledger_attr: 4242,
-          ledger_hash: "ledger-hash",
-          ledger_closed_at: "2025-07-04T08:30:00Z",
-        },
-      );
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
+          ledger_hash: 'ledger-hash',
+          ledger_closed_at: '2025-07-04T08:30:00Z',
+        }
+      )
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
       expect(out.tx.block).toEqual({
-        hash: "ledger-hash",
+        hash: 'ledger-hash',
         height: 4242,
-        time: new Date("2025-07-04T08:30:00Z"),
-      });
-    });
+        time: new Date('2025-07-04T08:30:00Z'),
+      })
+    })
 
     it("should set tx.date from the operation's created_at", async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "1",
-        created_at: "2024-02-29T01:02:03Z",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.tx.date).toEqual(new Date("2024-02-29T01:02:03Z"));
-    });
-
-    it("should include senders from the operation source_account", async () => {
+        amount: '1',
+        created_at: '2024-02-29T01:02:03Z',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.tx.date).toEqual(new Date('2024-02-29T01:02:03Z'))
+    })
+
+    it('should include senders from the operation source_account', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "1",
-        source_account: "GSOURCE",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.senders).toEqual(["GSOURCE"]);
-    });
-
-    it("should expose pagingToken and index in details", async () => {
+        amount: '1',
+        source_account: 'GSOURCE',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.senders).toEqual(['GSOURCE'])
+    })
+
+    it('should expose pagingToken and index in details', async () => {
       const op = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "1",
-        id: "op-42",
-        paging_token: "pt-42",
-      });
-      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0);
-      expect(out.details).toMatchObject({ pagingToken: "pt-42", index: "op-42" });
-    });
-  });
-
-  describe("batch processing", () => {
-    it("should preserve relative order of the operations that pass filters", async () => {
+        amount: '1',
+        id: 'op-42',
+        paging_token: 'pt-42',
+      })
+      const [out] = await rawOperationsToOperations([op], ADDR, ACCOUNT_ID, 0)
+      expect(out.details).toMatchObject({ pagingToken: 'pt-42', index: 'op-42' })
+    })
+  })
+
+  describe('batch processing', () => {
+    it('should preserve relative order of the operations that pass filters', async () => {
       const opA = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "1",
-        transaction_hash: "tx-a",
-      });
+        amount: '1',
+        transaction_hash: 'tx-a',
+      })
       // Unrelated to the listed address: not in any filter field and not the
       // fee payer, so it must be dropped entirely (no fee row).
       const opIgnored = makeOp(
         {
-          type: "manage_offer",
+          type: 'manage_offer',
           source_account: OTHER_ADDR,
-          transaction_hash: "tx-ignored",
+          transaction_hash: 'tx-ignored',
         },
-        { fee_account: OTHER_ADDR },
-      );
+        { fee_account: OTHER_ADDR }
+      )
       const opB = makeOp({
-        type: "payment",
+        type: 'payment',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "2",
+        amount: '2',
         source_account: OTHER_ADDR,
-        transaction_hash: "tx-b",
-      });
+        transaction_hash: 'tx-b',
+      })
 
-      const result = await rawOperationsToOperations([opA, opIgnored, opB], ADDR, ACCOUNT_ID, 0);
-      expect(result.map(o => o.tx.hash)).toEqual(["tx-a", "tx-b"]);
-    });
+      const result = await rawOperationsToOperations([opA, opIgnored, opB], ADDR, ACCOUNT_ID, 0)
+      expect(result.map((o) => o.tx.hash)).toEqual(['tx-a', 'tx-b'])
+    })
 
-    it("should interleave fee-only ops at the position of their first raw op in the page", async () => {
+    it('should interleave fee-only ops at the position of their first raw op in the page', async () => {
       const opA = makeOp({
-        type: "payment",
+        type: 'payment',
         from: ADDR,
         to: OTHER_ADDR,
-        amount: "1",
-        transaction_hash: "tx-a",
-      });
+        amount: '1',
+        transaction_hash: 'tx-a',
+      })
       const opFeeOnly = makeOp(
         {
-          type: "set_options",
+          type: 'set_options',
           source_account: ADDR,
-          transaction_hash: "tx-fees",
+          transaction_hash: 'tx-fees',
         },
-        { fee_account: ADDR, fee_charged: "100" },
-      );
+        { fee_account: ADDR, fee_charged: '100' }
+      )
       const opB = makeOp({
-        type: "payment",
+        type: 'payment',
         from: OTHER_ADDR,
         to: ADDR,
-        amount: "2",
+        amount: '2',
         source_account: OTHER_ADDR,
-        transaction_hash: "tx-b",
-      });
-
-      const result = await rawOperationsToOperations([opA, opFeeOnly, opB], ADDR, ACCOUNT_ID, 0);
-      expect(result.map(o => `${o.tx.hash}:${o.type}`)).toEqual([
-        "tx-a:OUT",
-        "tx-fees:FEES",
-        "tx-b:IN",
-      ]);
-    });
-
-    it("should return an empty array when given no operations", async () => {
-      expect(await rawOperationsToOperations([], ADDR, ACCOUNT_ID, 0)).toEqual([]);
-    });
-  });
-});
+        transaction_hash: 'tx-b',
+      })
+
+      const result = await rawOperationsToOperations([opA, opFeeOnly, opB], ADDR, ACCOUNT_ID, 0)
+      expect(result.map((o) => `${o.tx.hash}:${o.type}`)).toEqual([
+        'tx-a:OUT',
+        'tx-fees:FEES',
+        'tx-b:IN',
+      ])
+    })
+
+    it('should return an empty array when given no operations', async () => {
+      expect(await rawOperationsToOperations([], ADDR, ACCOUNT_ID, 0)).toEqual([])
+    })
+  })
+})