@ledgerhq/coin-stellar 6.26.0 → 6.26.1

package/src/logic/validateIntent.ts

@@ -1,10 +1,13 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
 import {
   TransactionValidation,
   TransactionIntent,
   FeeEstimation,
   Balance,
-} from "@ledgerhq/coin-module-framework/api/types";
-import { formatCurrencyUnit } from "@ledgerhq/coin-module-framework/currencies/index";
+} from '@ledgerhq/coin-module-framework/api/types'
+import { formatCurrencyUnit } from '@ledgerhq/coin-module-framework/currencies/index'
 import {
   AmountRequired,
   InvalidAddress,
@@ -13,11 +16,11 @@ import {
   NotEnoughBalanceBecauseDestinationNotCreated,
   NotEnoughSpendableBalance,
   RecipientRequired,
-} from "@ledgerhq/errors";
-import BigNumber from "bignumber.js";
-import { fetchAccountNetworkInfo, getRecipientAccount } from "../network";
-import { fetchAccount } from "../network/horizon";
-import { BASE_RESERVE, MIN_BALANCE } from "../network/serialization";
+} from '@ledgerhq/errors'
+import BigNumber from 'bignumber.js'
+import { fetchAccountNetworkInfo, getRecipientAccount } from '../network'
+import { fetchAccount } from '../network/horizon'
+import { BASE_RESERVE, MIN_BALANCE } from '../network/serialization'
 import {
   StellarAssetNotAccepted,
   StellarAssetNotFound,
@@ -30,108 +33,108 @@ import {
   StellarNotEnoughNativeBalanceToAddTrustline,
   StellarSourceHasMultiSign,
   StellarWrongMemoFormat,
-} from "../types";
-import { isAccountMultiSign, isAddressValid } from "./utils";
-import { validateMemo } from "./validateMemo";
+} from '../types'
+import { isAccountMultiSign, isAddressValid } from './utils'
+import { validateMemo } from './validateMemo'
 
 export const validateIntent = async (
   transactionIntent: TransactionIntent<StellarMemo>,
   balances: Balance[],
-  customFees?: FeeEstimation,
+  customFees?: FeeEstimation
 ): Promise<TransactionValidation> => {
-  const errors: Record<string, Error> = {};
-  const warnings: Record<string, Error> = {};
-  const useAllAmount = !!transactionIntent.useAllAmount;
+  const errors: Record<string, Error> = {}
+  const warnings: Record<string, Error> = {}
+  const useAllAmount = !!transactionIntent.useAllAmount
 
-  const destinationNotExistMessage = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+  const destinationNotExistMessage = new NotEnoughBalanceBecauseDestinationNotCreated('', {
     minimalAmount: `${MIN_BALANCE} XLM`,
-  });
+  })
 
-  const { spendableBalance, balance } = await fetchAccount(transactionIntent.sender);
-  const networkInfo = await fetchAccountNetworkInfo(transactionIntent.sender);
+  const { spendableBalance, balance } = await fetchAccount(transactionIntent.sender)
+  const networkInfo = await fetchAccountNetworkInfo(transactionIntent.sender)
 
-  const estimatedFees = customFees?.value ?? 0n;
+  const estimatedFees = customFees?.value ?? 0n
   const baseReserve = networkInfo.baseReserve
     ? BigInt(Math.round(networkInfo.baseReserve.toNumber() * 10)) / 10n
-    : 0n;
-  const isAssetPayment = transactionIntent.asset.type !== "native";
-  const nativeBalance = BigInt(balance.toString());
-  const nativeAmountAvailable = BigInt(spendableBalance.toString()) - estimatedFees;
-  let amount = 0n;
-  let maxAmount = 0n;
-  let totalSpent = 0n;
+    : 0n
+  const isAssetPayment = transactionIntent.asset.type !== 'native'
+  const nativeBalance = BigInt(balance.toString())
+  const nativeAmountAvailable = BigInt(spendableBalance.toString()) - estimatedFees
+  let amount = 0n
+  let maxAmount = 0n
+  let totalSpent = 0n
 
   // Enough native balance to cover transaction (with required reserve + fees)
   if (!errors.amount && nativeAmountAvailable < 0) {
-    errors.amount = new StellarNotEnoughNativeBalance();
+    errors.amount = new StellarNotEnoughNativeBalance()
   }
 
-  const networkInfoBaseFee = BigInt(networkInfo.baseFee.toString() || "0");
-  const networkFees = BigInt(networkInfo.fees.toString() || "0");
+  const networkInfoBaseFee = BigInt(networkInfo.baseFee.toString() || '0')
+  const networkFees = BigInt(networkInfo.fees.toString() || '0')
   // Entered fee is smaller than base fee
   if (estimatedFees < networkInfoBaseFee) {
-    errors.transaction = new StellarFeeSmallerThanBase();
+    errors.transaction = new StellarFeeSmallerThanBase()
     // Entered fee is smaller than recommended
   } else if (estimatedFees < networkFees) {
-    warnings.transaction = new StellarFeeSmallerThanRecommended();
+    warnings.transaction = new StellarFeeSmallerThanRecommended()
   }
 
   // Operation specific checks
-  if (transactionIntent.type === "changeTrust") {
+  if (transactionIntent.type === 'changeTrust') {
     // Check asset provided
     if (
-      transactionIntent.asset.type !== "native" &&
-      (("assetReference" in transactionIntent.asset && !transactionIntent.asset.assetReference) ||
-        ("assetOwner" in transactionIntent.asset && !transactionIntent.asset.assetOwner))
+      transactionIntent.asset.type !== 'native' &&
+      (('assetReference' in transactionIntent.asset && !transactionIntent.asset.assetReference) ||
+        ('assetOwner' in transactionIntent.asset && !transactionIntent.asset.assetOwner))
     ) {
       // This is unlikely
-      errors.transaction = new StellarAssetRequired("");
+      errors.transaction = new StellarAssetRequired('')
     }
 
     // Has enough native balance to add new trustline
     // NOTE: need to do this as BASE_RESERVE is 0.5
-    const SCALE = 10n;
-    const scaledNative = nativeAmountAvailable * SCALE;
-    const scaledBaseReserve = BigInt(BASE_RESERVE * 10); // = 5n
+    const SCALE = 10n
+    const scaledNative = nativeAmountAvailable * SCALE
+    const scaledBaseReserve = BigInt(BASE_RESERVE * 10) // = 5n
 
     if (scaledNative - scaledBaseReserve < 0n) {
-      errors.amount = new StellarNotEnoughNativeBalanceToAddTrustline();
+      errors.amount = new StellarNotEnoughNativeBalanceToAddTrustline()
     }
   } else {
     // Payment
     // Check recipient address
     if (!transactionIntent.recipient) {
-      errors.recipient = new RecipientRequired("");
+      errors.recipient = new RecipientRequired('')
     } else if (!isAddressValid(transactionIntent.recipient)) {
-      errors.recipient = new InvalidAddress("", {
-        currencyName: transactionIntent.asset.name ?? "", // NOTE: before account.currencyName,
-      });
+      errors.recipient = new InvalidAddress('', {
+        currencyName: transactionIntent.asset.name ?? '', // NOTE: before account.currencyName,
+      })
     } else if (transactionIntent.sender === transactionIntent.recipient) {
-      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource()
     }
 
     const recipientAccount = await getRecipientAccount({
       recipient: transactionIntent.recipient,
-    });
+    })
 
     // Check recipient account
     if (!recipientAccount?.id && !errors.recipient && !warnings.recipient) {
       if (recipientAccount?.isMuxedAccount) {
-        errors.recipient = new StellarMuxedAccountNotExist();
+        errors.recipient = new StellarMuxedAccountNotExist()
       } else {
         if (isAssetPayment) {
-          errors.recipient = destinationNotExistMessage;
+          errors.recipient = destinationNotExistMessage
         } else {
-          warnings.recipient = destinationNotExistMessage;
+          warnings.recipient = destinationNotExistMessage
         }
       }
     }
 
     // Asset payment
     if (isAssetPayment) {
-      const asset = transactionIntent.asset;
-      if (asset.type === "native" || (!("assetReference" in asset) && !("assetOwner" in asset))) {
-        throw new StellarAssetNotFound();
+      const asset = transactionIntent.asset
+      if (asset.type === 'native' || (!('assetReference' in asset) && !('assetOwner' in asset))) {
+        throw new StellarAssetNotFound()
       }
 
       // Check recipient account accepts asset
@@ -141,47 +144,47 @@ export const validateIntent = async (
         !warnings.recipient &&
         !recipientAccount.assetIds.includes(`${asset.assetReference}:${asset.assetOwner}`)
       ) {
-        errors.recipient = new StellarAssetNotAccepted("", {
+        errors.recipient = new StellarAssetNotAccepted('', {
           assetCode: asset.assetReference,
-        });
+        })
       }
 
       const assetBalance = balances.find(
-        b =>
-          b.asset.type !== "native" &&
-          "assetReference" in b.asset &&
+        (b) =>
+          b.asset.type !== 'native' &&
+          'assetReference' in b.asset &&
           b.asset.assetReference === asset.assetReference &&
-          "assetOwner" in b.asset &&
-          b.asset.assetOwner === asset.assetOwner,
-      );
+          'assetOwner' in b.asset &&
+          b.asset.assetOwner === asset.assetOwner
+      )
 
       if (!assetBalance) {
         // This is unlikely
-        throw new StellarAssetNotFound();
+        throw new StellarAssetNotFound()
       }
-      const assetSpendableBalance = assetBalance.value - (assetBalance?.locked || 0n);
+      const assetSpendableBalance = assetBalance.value - (assetBalance?.locked || 0n)
 
-      maxAmount = assetSpendableBalance || assetBalance.value;
-      amount = useAllAmount ? maxAmount : transactionIntent.amount;
-      totalSpent = amount;
+      maxAmount = assetSpendableBalance || assetBalance.value
+      amount = useAllAmount ? maxAmount : transactionIntent.amount
+      totalSpent = amount
 
       if (!errors.amount && amount > assetBalance.value) {
-        errors.amount = new NotEnoughBalance();
+        errors.amount = new NotEnoughBalance()
       }
     } else {
       // Native payment
-      maxAmount = nativeAmountAvailable;
-      amount = useAllAmount ? maxAmount : (transactionIntent.amount ?? 0n);
+      maxAmount = nativeAmountAvailable
+      amount = useAllAmount ? maxAmount : (transactionIntent.amount ?? 0n)
 
       if (amount > maxAmount) {
-        errors.amount = new NotEnoughBalance();
+        errors.amount = new NotEnoughBalance()
       }
 
-      totalSpent = useAllAmount ? nativeAmountAvailable : amount + estimatedFees;
+      totalSpent = useAllAmount ? nativeAmountAvailable : amount + estimatedFees
 
       // Need to send at least 1 XLM to create an account
       if (!errors.recipient && !recipientAccount?.id && !errors.amount && amount < 10000000n) {
-        errors.amount = destinationNotExistMessage;
+        errors.amount = destinationNotExistMessage
       }
       if (totalSpent > nativeBalance - baseReserve) {
         errors.amount = new NotEnoughSpendableBalance(undefined, {
@@ -192,33 +195,33 @@ export const validateIntent = async (
                 {
                   disableRounding: true,
                   showCode: true,
-                },
+                }
               )
-            : "Unknown unit",
-        });
+            : 'Unknown unit',
+        })
       }
 
       if (!errors.recipient && !errors.amount && (amount < 0n || totalSpent > nativeBalance)) {
-        errors.amount = new NotEnoughBalance();
-        totalSpent = 0n;
-        amount = 0n;
+        errors.amount = new NotEnoughBalance()
+        totalSpent = 0n
+        amount = 0n
       }
     }
 
     if (amount === 0n) {
-      errors.amount = new AmountRequired();
+      errors.amount = new AmountRequired()
     }
   }
 
   if (await isAccountMultiSign(transactionIntent.sender)) {
-    errors.recipient = new StellarSourceHasMultiSign();
+    errors.recipient = new StellarSourceHasMultiSign()
   }
 
   if (
-    transactionIntent?.memo?.type !== "NO_MEMO" &&
+    transactionIntent?.memo?.type !== 'NO_MEMO' &&
     !validateMemo(transactionIntent?.memo?.value, transactionIntent?.memo?.type)
   ) {
-    errors.transaction = new StellarWrongMemoFormat();
+    errors.transaction = new StellarWrongMemoFormat()
   }
 
   return {
@@ -227,7 +230,7 @@ export const validateIntent = async (
     estimatedFees,
     amount,
     totalSpent,
-  };
-};
+  }
+}
 
-export default validateIntent;
+export default validateIntent

package/src/logic/validateMemo.test.ts

@@ -1,61 +1,64 @@
-import { MEMO_HASH_FIXED_SIZE, MEMO_TEXT_MAXIMUM_SIZE, validateMemo } from "./validateMemo";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-describe("validateMemo", () => {
-  it("should return false when type is NO_MEMO but memo is present", () => {
-    const memo = "memo";
-    expect(validateMemo(memo, "NO_MEMO")).toEqual(false);
-  });
+import { MEMO_HASH_FIXED_SIZE, MEMO_TEXT_MAXIMUM_SIZE, validateMemo } from './validateMemo'
 
-  it("should return true when type is NO_MEMO and memo is empty", () => {
-    expect(validateMemo("", "NO_MEMO")).toEqual(true);
-  });
+describe('validateMemo', () => {
+  it('should return false when type is NO_MEMO but memo is present', () => {
+    const memo = 'memo'
+    expect(validateMemo(memo, 'NO_MEMO')).toEqual(false)
+  })
 
-  it.each(["a".repeat(MEMO_TEXT_MAXIMUM_SIZE + 1), "a".repeat(MEMO_TEXT_MAXIMUM_SIZE + 2)])(
-    "should return false when type is MEMO_TEXT but memo exceed maximum allowed size",
+  it('should return true when type is NO_MEMO and memo is empty', () => {
+    expect(validateMemo('', 'NO_MEMO')).toEqual(true)
+  })
+
+  it.each(['a'.repeat(MEMO_TEXT_MAXIMUM_SIZE + 1), 'a'.repeat(MEMO_TEXT_MAXIMUM_SIZE + 2)])(
+    'should return false when type is MEMO_TEXT but memo exceed maximum allowed size',
     (memo: string) => {
-      expect(validateMemo(memo, "MEMO_TEXT")).toEqual(false);
-    },
-  );
+      expect(validateMemo(memo, 'MEMO_TEXT')).toEqual(false)
+    }
+  )
 
-  it.each(["memo", "a".repeat(MEMO_TEXT_MAXIMUM_SIZE), "a".repeat(MEMO_TEXT_MAXIMUM_SIZE - 1)])(
-    "should return true when type is MEMO_TEXT and memo is under maximum allowed size",
+  it.each(['memo', 'a'.repeat(MEMO_TEXT_MAXIMUM_SIZE), 'a'.repeat(MEMO_TEXT_MAXIMUM_SIZE - 1)])(
+    'should return true when type is MEMO_TEXT and memo is under maximum allowed size',
     (memo: string) => {
-      expect(validateMemo(memo, "MEMO_TEXT")).toEqual(true);
-    },
-  );
+      expect(validateMemo(memo, 'MEMO_TEXT')).toEqual(true)
+    }
+  )
 
-  it("should return false when type is MEMO_ID and memo is NaN", () => {
-    expect(validateMemo(Number.NaN.toString(), "MEMO_ID")).toEqual(false);
-  });
+  it('should return false when type is MEMO_ID and memo is NaN', () => {
+    expect(validateMemo(Number.NaN.toString(), 'MEMO_ID')).toEqual(false)
+  })
 
-  it.each(["0", "1", "-1", "123.456"])(
-    "should return true when type is MEMO_ID and memo is a number",
+  it.each(['0', '1', '-1', '123.456'])(
+    'should return true when type is MEMO_ID and memo is a number',
     (memo: string) => {
-      expect(validateMemo(memo, "MEMO_ID")).toEqual(true);
-    },
-  );
+      expect(validateMemo(memo, 'MEMO_ID')).toEqual(true)
+    }
+  )
 
-  it.each(["", "a", "a".repeat(MEMO_HASH_FIXED_SIZE + 1), "a".repeat(MEMO_HASH_FIXED_SIZE - 1)])(
-    "should return false when type is MEMO_HASH and memo has the wrong size",
+  it.each(['', 'a', 'a'.repeat(MEMO_HASH_FIXED_SIZE + 1), 'a'.repeat(MEMO_HASH_FIXED_SIZE - 1)])(
+    'should return false when type is MEMO_HASH and memo has the wrong size',
     (memo: string) => {
-      expect(validateMemo(memo, "MEMO_HASH")).toEqual(false);
-    },
-  );
+      expect(validateMemo(memo, 'MEMO_HASH')).toEqual(false)
+    }
+  )
 
-  it("should return true when type is MEMO_HASH and memo has the wrong size", () => {
-    const memo = "a".repeat(MEMO_HASH_FIXED_SIZE);
-    expect(validateMemo(memo, "MEMO_HASH")).toEqual(true);
-  });
+  it('should return true when type is MEMO_HASH and memo has the wrong size', () => {
+    const memo = 'a'.repeat(MEMO_HASH_FIXED_SIZE)
+    expect(validateMemo(memo, 'MEMO_HASH')).toEqual(true)
+  })
 
-  it.each(["", "a", "a".repeat(MEMO_HASH_FIXED_SIZE + 1), "a".repeat(MEMO_HASH_FIXED_SIZE - 1)])(
-    "should return false when type is MEMO_RETURN and memo has the wrong size",
+  it.each(['', 'a', 'a'.repeat(MEMO_HASH_FIXED_SIZE + 1), 'a'.repeat(MEMO_HASH_FIXED_SIZE - 1)])(
+    'should return false when type is MEMO_RETURN and memo has the wrong size',
     (memo: string) => {
-      expect(validateMemo(memo, "MEMO_RETURN")).toEqual(false);
-    },
-  );
-
-  it("should return true when type is MEMO_RETURN and memo has the wrong size", () => {
-    const memo = "a".repeat(MEMO_HASH_FIXED_SIZE);
-    expect(validateMemo(memo, "MEMO_RETURN")).toEqual(true);
-  });
-});
+      expect(validateMemo(memo, 'MEMO_RETURN')).toEqual(false)
+    }
+  )
+
+  it('should return true when type is MEMO_RETURN and memo has the wrong size', () => {
+    const memo = 'a'.repeat(MEMO_HASH_FIXED_SIZE)
+    expect(validateMemo(memo, 'MEMO_RETURN')).toEqual(true)
+  })
+})

package/src/logic/validateMemo.ts

@@ -1,19 +1,22 @@
-import BigNumber from "bignumber.js";
-import { StellarMemoKind } from "../types/model";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-export const MEMO_TEXT_MAXIMUM_SIZE = 28;
-export const MEMO_HASH_FIXED_SIZE = 64;
+import BigNumber from 'bignumber.js'
+import { StellarMemoKind } from '../types/model'
+
+export const MEMO_TEXT_MAXIMUM_SIZE = 28
+export const MEMO_HASH_FIXED_SIZE = 64
 
 export function validateMemo(memo: string, type: StellarMemoKind): boolean {
   switch (type) {
-    case "NO_MEMO":
-      return !memo || memo.length === 0;
-    case "MEMO_TEXT":
-      return memo.length <= MEMO_TEXT_MAXIMUM_SIZE;
-    case "MEMO_ID":
-      return !new BigNumber(memo.toString()).isNaN();
-    case "MEMO_HASH":
-    case "MEMO_RETURN":
-      return memo.length === 64;
+    case 'NO_MEMO':
+      return !memo || memo.length === 0
+    case 'MEMO_TEXT':
+      return memo.length <= MEMO_TEXT_MAXIMUM_SIZE
+    case 'MEMO_ID':
+      return !new BigNumber(memo.toString()).isNaN()
+    case 'MEMO_HASH':
+    case 'MEMO_RETURN':
+      return memo.length === 64
   }
 }

package/src/network/broadcastTransaction.test.ts

@@ -1,98 +1,98 @@
-import { BadResponseError, Horizon } from "@stellar/stellar-sdk";
-import coinConfig from "../config";
-import { broadcastTransaction } from "./horizon";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { BadResponseError, Horizon } from '@stellar/stellar-sdk'
+import coinConfig from '../config'
+import { broadcastTransaction } from './horizon'
 
 /** Parses on mainnet; used only so `submitTransaction` is reached (mocked). */
 const tx =
-  "AAAAAgAAAABRUCgFba+DTbei2ifpyYt5w2Hh0VyZ+X9fayjIDne7YAAAAGQCkDOGAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAACEIuPfWXgM8WhyqjrpFdIcGV1SUVhMzPUm4YspNHF60QAAAAAAAAAAALkd2QAAAAAAAAABDne7YAAAAEAASzsT/yDIfCfEDstkfnznXjiN7rNd7PkKQEn+rRIFm9EHoirGfHipWoBdYMrc6ixQD/0y0of1piSid8TLiFAB";
+  'AAAAAgAAAABRUCgFba+DTbei2ifpyYt5w2Hh0VyZ+X9fayjIDne7YAAAAGQCkDOGAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAACEIuPfWXgM8WhyqjrpFdIcGV1SUVhMzPUm4YspNHF60QAAAAAAAAAAALkd2QAAAAAAAAABDne7YAAAAEAASzsT/yDIfCfEDstkfnznXjiN7rNd7PkKQEn+rRIFm9EHoirGfHipWoBdYMrc6ixQD/0y0of1piSid8TLiFAB'
 
 function horizonTransactionFailedExtras() {
   return {
-    type: "https://stellar.org/horizon-errors/transaction_failed",
-    title: "Transaction Failed",
+    type: 'https://stellar.org/horizon-errors/transaction_failed',
+    title: 'Transaction Failed',
     status: 400,
-    detail: "The transaction failed when submitted to the stellar network.",
+    detail: 'The transaction failed when submitted to the stellar network.',
     extras: {
       result_codes: {
-        transaction: "tx_failed" as const,
-        operations: ["op_no_account"] as string[],
+        transaction: 'tx_failed' as const,
+        operations: ['op_no_account'] as string[],
       },
-      result_xdr: "AAAAAAAAAGT////4AAAAAA==",
+      result_xdr: 'AAAAAAAAAGT////4AAAAAA==',
       envelope_xdr: tx,
     },
-  };
+  }
 }
 
-describe("broadcastTransaction", () => {
-  let submitTransactionSpy: jest.SpiedFunction<Horizon.Server["submitTransaction"]>;
+describe('broadcastTransaction', () => {
+  let submitTransactionSpy: jest.SpiedFunction<Horizon.Server['submitTransaction']>
 
   beforeAll(() => {
     coinConfig.setCoinConfig(() => ({
-      explorer: { url: "https://horizon-broadcast-unit-test.invalid/" },
-      status: { type: "active" },
-    }));
-  });
+      explorer: { url: 'https://horizon-broadcast-unit-test.invalid/' },
+      status: { type: 'active' },
+    }))
+  })
 
   beforeEach(() => {
     submitTransactionSpy = jest
-      .spyOn(Horizon.Server.prototype, "submitTransaction")
-      .mockRejectedValue(new Error("mock not configured"));
-  });
+      .spyOn(Horizon.Server.prototype, 'submitTransaction')
+      .mockRejectedValue(new Error('mock not configured'))
+  })
 
   afterEach(() => {
-    submitTransactionSpy.mockRestore();
-  });
+    submitTransactionSpy.mockRestore()
+  })
 
-  it("maps BadResponseError with Horizon body on error.response to StellarBroadcastFailedError", async () => {
-    const body = horizonTransactionFailedExtras();
+  it('maps BadResponseError with Horizon body on error.response to StellarBroadcastFailedError', async () => {
+    const body = horizonTransactionFailedExtras()
     submitTransactionSpy.mockRejectedValue(
-      new BadResponseError(
-        "Transaction submission failed. Server responded: 400 Bad Request",
-        body,
-      ),
-    );
+      new BadResponseError('Transaction submission failed. Server responded: 400 Bad Request', body)
+    )
 
     await expect(broadcastTransaction(tx)).rejects.toMatchObject({
-      name: "StellarBroadcastFailedError",
-      horizonTransactionCode: "tx_failed",
+      name: 'StellarBroadcastFailedError',
+      horizonTransactionCode: 'tx_failed',
       cause: expect.any(BadResponseError),
-    });
-  });
+    })
+  })
 
-  it("maps axios-like error with Horizon body on error.response.data to StellarBroadcastFailedError", async () => {
-    const body = horizonTransactionFailedExtras();
+  it('maps axios-like error with Horizon body on error.response.data to StellarBroadcastFailedError', async () => {
+    const body = horizonTransactionFailedExtras()
     submitTransactionSpy.mockRejectedValue(
-      Object.assign(new Error("Request failed with status code 400"), {
-        name: "AxiosError",
-        response: { status: 400, statusText: "Bad Request", data: body },
-      }),
-    );
+      Object.assign(new Error('Request failed with status code 400'), {
+        name: 'AxiosError',
+        response: { status: 400, statusText: 'Bad Request', data: body },
+      })
+    )
 
     await expect(broadcastTransaction(tx)).rejects.toMatchObject({
-      name: "StellarBroadcastFailedError",
-      horizonTransactionCode: "tx_failed",
-      cause: expect.objectContaining({ name: "AxiosError" }),
-    });
-  });
+      name: 'StellarBroadcastFailedError',
+      horizonTransactionCode: 'tx_failed',
+      cause: expect.objectContaining({ name: 'AxiosError' }),
+    })
+  })
 
-  it("rethrows a plain error with no Horizon payload unchanged (same reference)", async () => {
-    const original = new Error("ECONNREFUSED");
-    submitTransactionSpy.mockRejectedValue(original);
+  it('rethrows a plain error with no Horizon payload unchanged (same reference)', async () => {
+    const original = new Error('ECONNREFUSED')
+    submitTransactionSpy.mockRejectedValue(original)
 
-    await expect(broadcastTransaction(tx)).rejects.toBe(original);
-  });
+    await expect(broadcastTransaction(tx)).rejects.toBe(original)
+  })
 
-  it("rethrows an axios-like error when response.data is not a Horizon transaction failure body", async () => {
-    const original = Object.assign(new Error("Request failed with status code 500"), {
-      name: "AxiosError",
+  it('rethrows an axios-like error when response.data is not a Horizon transaction failure body', async () => {
+    const original = Object.assign(new Error('Request failed with status code 500'), {
+      name: 'AxiosError',
       response: {
         status: 500,
-        statusText: "Internal Server Error",
-        data: { title: "Internal Server Error" },
+        statusText: 'Internal Server Error',
+        data: { title: 'Internal Server Error' },
       },
-    });
-    submitTransactionSpy.mockRejectedValue(original);
+    })
+    submitTransactionSpy.mockRejectedValue(original)
 
-    await expect(broadcastTransaction(tx)).rejects.toBe(original);
-  });
-});
+    await expect(broadcastTransaction(tx)).rejects.toBe(original)
+  })
+})