@ledgerhq/coin-stellar 6.26.0 → 6.26.2

package/src/network/horizonErrorBody.test.ts

@@ -0,0 +1,133 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { BadResponseError } from '@stellar/stellar-sdk'
+import {
+  documentationSummaryFromHorizonBody,
+  getHorizonErrorBody,
+  isHorizonErrorBody,
+} from './horizonErrorBody'
+
+describe('isHorizonErrorBody', () => {
+  it('accepts RFC 7807 problem bodies with title and status', () => {
+    expect(
+      isHorizonErrorBody({
+        type: 'https://stellar.org/horizon-errors/transaction_malformed',
+        title: 'Transaction Malformed',
+        status: 400,
+        detail: 'Horizon could not decode the transaction envelope in this request.',
+      })
+    ).toBe(true)
+  })
+
+  it('rejects non-problem payloads', () => {
+    expect(isHorizonErrorBody({ title: 'Missing status' })).toBe(false)
+    expect(isHorizonErrorBody(null)).toBe(false)
+  })
+})
+
+describe('getHorizonErrorBody', () => {
+  const body = {
+    type: 'https://stellar.org/horizon-errors/bad_request',
+    title: 'Bad Request',
+    status: 400,
+    detail: 'Invalid cursor.',
+    extras: { reason: 'cursor is invalid' },
+  }
+
+  it('reads BadResponseError.response', () => {
+    const error = new BadResponseError('bad', body)
+    expect(getHorizonErrorBody(error)).toEqual(body)
+  })
+
+  it('reads axios-like error.response.data', () => {
+    const error = Object.assign(new Error('Request failed with status code 400'), {
+      response: { data: body },
+    })
+    expect(getHorizonErrorBody(error)).toEqual(body)
+  })
+})
+
+describe('documentationSummaryFromHorizonBody', () => {
+  const genericDetail =
+    'The transaction failed when submitted to the Stellar network. The `extras.result_codes` field on this response contains further details.'
+
+  it('prefers operation result code over generic tx_failed', () => {
+    expect(
+      documentationSummaryFromHorizonBody({
+        title: 'Transaction Failed',
+        status: 400,
+        detail: genericDetail,
+        extras: {
+          result_codes: {
+            transaction: 'tx_failed',
+            operations: ['op_underfunded'],
+          },
+        },
+      })
+    ).toBe(
+      'The source account does not have enough balance to send the payment amount while maintaining its minimum reserve.'
+    )
+  })
+
+  it('skips op_inner and uses the first failing operation code', () => {
+    expect(
+      documentationSummaryFromHorizonBody({
+        title: 'Transaction Failed',
+        status: 400,
+        detail: genericDetail,
+        extras: {
+          result_codes: {
+            transaction: 'tx_failed',
+            operations: ['op_inner', 'op_underfunded'],
+          },
+        },
+      })
+    ).toBe(
+      'The source account does not have enough balance to send the payment amount while maintaining its minimum reserve.'
+    )
+  })
+
+  it('uses transaction code when it is specific', () => {
+    expect(
+      documentationSummaryFromHorizonBody({
+        title: 'Transaction Failed',
+        status: 400,
+        detail: genericDetail,
+        extras: {
+          result_codes: { transaction: 'tx_bad_seq' },
+        },
+      })
+    ).toBe('Sequence number does not match source account.')
+  })
+
+  it('uses Horizon detail when no result codes are present', () => {
+    expect(
+      documentationSummaryFromHorizonBody({
+        title: 'Transaction Malformed',
+        status: 400,
+        detail: 'Horizon could not decode the transaction envelope in this request.',
+        extras: { envelope_xdr: 'AAAA' },
+      })
+    ).toBe('Horizon could not decode the transaction envelope in this request.')
+  })
+
+  it('uses extras.reason for validation errors', () => {
+    expect(
+      documentationSummaryFromHorizonBody({
+        title: 'Bad Request',
+        status: 400,
+        extras: { invalid_field: 'cursor', reason: 'cursor is invalid' },
+      })
+    ).toBe('cursor is invalid (field: cursor)')
+  })
+
+  it('falls back to title when nothing else is available', () => {
+    expect(
+      documentationSummaryFromHorizonBody({
+        title: 'Rate Limited',
+        status: 429,
+      })
+    ).toBe('Rate Limited')
+  })
+})

package/src/network/horizonErrorBody.ts

@@ -0,0 +1,178 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { BadResponseError } from '@stellar/stellar-sdk'
+
+/** Horizon RFC 7807 problem+json body (subset used by coin-stellar). */
+export type HorizonErrorBody = {
+  type?: string
+  title?: string
+  status?: number
+  detail?: string
+  extras?: {
+    envelope_xdr?: string
+    result_xdr?: string
+    result_codes?: {
+      transaction?: string
+      operations?: string[]
+    }
+    invalid_field?: string
+    reason?: string
+  }
+}
+
+const GENERIC_TRANSACTION_FAILED_DETAIL =
+  /The transaction failed when submitted to the Stellar network/i
+
+/** Horizon `extras.result_codes.transaction` → one-line description (Stellar docs). */
+const HORIZON_TRANSACTION_RESULT_CODE_DOCUMENTATION: Record<string, string> = {
+  tx_success: 'The transaction succeeded.',
+  tx_failed: 'One of the operations failed (none were applied).',
+  tx_too_early: 'The ledger closeTime was before the minTime.',
+  tx_too_late: 'The ledger closeTime was after the maxTime.',
+  tx_missing_operation: 'No operation was specified.',
+  tx_bad_seq: 'Sequence number does not match source account.',
+  tx_bad_auth: 'Too few valid signatures / wrong network.',
+  tx_insufficient_balance: 'Fee would bring account below reserve.',
+  tx_no_source_account: 'Source account not found.',
+  tx_insufficient_fee: 'Fee is too small.',
+  tx_bad_auth_extra: 'Unused signatures attached to transaction.',
+  tx_internal_error: 'An unknown error occurred.',
+  tx_fee_bump_inner_success: 'Fee bump inner transaction succeeded.',
+  tx_fee_bump_inner_failed: 'Fee bump inner transaction failed.',
+  tx_not_supported: 'Transaction type not supported.',
+  tx_bad_sponsorship: 'Sponsorship is invalid.',
+  tx_bad_min_seq_age_or_gap: 'Minimum sequence age or gap precondition failed.',
+  tx_malformed: 'Transaction is malformed.',
+  tx_soroban_invalid: 'Soroban transaction is invalid.',
+}
+
+/** Horizon `extras.result_codes.operations[]` → one-line description (Stellar docs). */
+const HORIZON_OPERATION_RESULT_CODE_DOCUMENTATION: Record<string, string> = {
+  op_inner: 'The inner object result is valid and the operation was a success.',
+  op_bad_auth:
+    'There are too few valid signatures, or the transaction was submitted to the wrong network.',
+  op_no_source_account: 'The source account was not found.',
+  op_no_account: 'The source account was not found.',
+  op_not_supported: 'The operation is not supported at this time.',
+  op_too_many_subentries: 'Max number of subentries (1000) already reached.',
+  op_exceeded_work_limit: 'Operation did too much work.',
+  op_malformed: 'The operation input is invalid.',
+  op_underfunded:
+    'The source account does not have enough balance to send the payment amount while maintaining its minimum reserve.',
+  op_src_no_trust:
+    'The source account does not have a trustline for the asset it is trying to send.',
+  op_src_not_authorized: 'The source account is not authorized to send this asset.',
+  op_no_destination: 'The destination account does not exist.',
+  op_no_trust: 'The destination account does not have a trustline for the asset being sent.',
+  op_not_authorized: 'The destination account is not authorized to hold this asset.',
+  op_line_full:
+    'The destination account does not have sufficient limits to receive the amount and still satisfy its buying liabilities.',
+  op_no_issuer: 'The issuer of the asset does not exist.',
+}
+
+/** Operation result codes that mark success for a prior op in a multi-op failure list. */
+const HORIZON_OPERATION_SUCCESS_RESULT_CODES = new Set<string>(['op_inner'])
+
+function failingOperationCode(operations: string[] | undefined): string | undefined {
+  return operations?.find((code) => !HORIZON_OPERATION_SUCCESS_RESULT_CODES.has(code))
+}
+
+export function isHorizonErrorBody(data: unknown): data is HorizonErrorBody {
+  return !!(
+    data &&
+    typeof data === 'object' &&
+    'title' in data &&
+    typeof data.title === 'string' &&
+    'status' in data &&
+    typeof data.status === 'number'
+  )
+}
+
+/**
+ * Horizon failures are usually {@link BadResponseError} with `response` = problem+json body.
+ * Axios rejects first; the SDK forwards it unchanged, so the body lives on `error.response.data`.
+ */
+export function getHorizonErrorBody(error: unknown): HorizonErrorBody | null {
+  if (error instanceof BadResponseError && isHorizonErrorBody(error.response)) {
+    return error.response
+  }
+  if (error && typeof error === 'object' && 'response' in error) {
+    const data = (error as { response?: { data?: unknown } }).response?.data
+    if (isHorizonErrorBody(data)) {
+      return data
+    }
+  }
+  return null
+}
+
+function lookupOperationDocumentation(operationCode: string | undefined): string | undefined {
+  if (!operationCode) {
+    return undefined
+  }
+  return HORIZON_OPERATION_RESULT_CODE_DOCUMENTATION[operationCode]
+}
+
+function lookupTransactionDocumentation(transactionCode: string | undefined): string | undefined {
+  if (!transactionCode) {
+    return undefined
+  }
+  return HORIZON_TRANSACTION_RESULT_CODE_DOCUMENTATION[transactionCode]
+}
+
+function detailDocumentation(body: HorizonErrorBody): string | undefined {
+  const detail = body.detail?.trim()
+  if (!detail || GENERIC_TRANSACTION_FAILED_DETAIL.test(detail)) {
+    return undefined
+  }
+  return detail
+}
+
+function extrasReasonDocumentation(body: HorizonErrorBody): string | undefined {
+  const reason = body.extras?.reason?.trim()
+  if (!reason) {
+    return undefined
+  }
+  const invalidField = body.extras?.invalid_field?.trim()
+  return invalidField ? `${reason} (field: ${invalidField})` : reason
+}
+
+/**
+ * Best-effort human-readable summary for logs (`errorExtras.documentationSummary`).
+ * Prefers operation result codes, then transaction codes, then Horizon `detail` / `extras.reason`.
+ */
+export function documentationSummaryFromHorizonBody(body: HorizonErrorBody): string {
+  const transactionCode = body.extras?.result_codes?.transaction
+  const operationCode = failingOperationCode(body.extras?.result_codes?.operations)
+
+  const operationSummary = lookupOperationDocumentation(operationCode)
+  if (operationSummary) {
+    return operationSummary
+  }
+
+  const transactionSummary = lookupTransactionDocumentation(transactionCode)
+  if (transactionSummary && transactionCode !== 'tx_failed') {
+    return transactionSummary
+  }
+
+  const detail = detailDocumentation(body)
+  if (detail) {
+    return detail
+  }
+
+  const extrasReason = extrasReasonDocumentation(body)
+  if (extrasReason) {
+    return extrasReason
+  }
+
+  if (transactionSummary) {
+    return transactionSummary
+  }
+
+  const title = body.title?.trim()
+  if (title) {
+    return title
+  }
+
+  return 'Unknown Horizon error.'
+}

package/src/network/horizonLedgerErrors.test.ts

@@ -1,112 +1,184 @@
-import { LedgerAPI4xx, LedgerAPI5xx, NetworkDown } from "@ledgerhq/errors";
-import { NetworkError, NotFoundError } from "@stellar/stellar-sdk";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { LedgerAPI4xx, LedgerAPI5xx, NetworkDown } from '@ledgerhq/errors'
+import { NetworkError, NotFoundError } from '@stellar/stellar-sdk'
 import {
   messageFromHorizonUnknown,
   throwHorizonLedgerOrOperationsError,
-} from "./horizonLedgerErrors";
+} from './horizonLedgerErrors'
+
+describe('messageFromHorizonUnknown', () => {
+  it('returns Horizon documentationSummary when response body is present', () => {
+    const error = Object.assign(new Error('Request failed with status code 400'), {
+      response: {
+        data: {
+          title: 'Transaction Malformed',
+          status: 400,
+          detail: 'Horizon could not decode the transaction envelope in this request.',
+        },
+      },
+    })
+    expect(messageFromHorizonUnknown(error)).toBe(
+      'Horizon could not decode the transaction envelope in this request.'
+    )
+  })
 
-describe("messageFromHorizonUnknown", () => {
-  it("returns message for Error", () => {
-    expect(messageFromHorizonUnknown(new Error("hello"))).toBe("hello");
-  });
+  it('returns message for Error', () => {
+    expect(messageFromHorizonUnknown(new Error('hello'))).toBe('hello')
+  })
 
-  it("returns string as-is", () => {
-    expect(messageFromHorizonUnknown("plain")).toBe("plain");
-  });
+  it('returns string as-is', () => {
+    expect(messageFromHorizonUnknown('plain')).toBe('plain')
+  })
 
-  it("returns empty string for non-Error non-string", () => {
-    expect(messageFromHorizonUnknown({ code: 1 })).toBe("");
-    expect(messageFromHorizonUnknown(null)).toBe("");
-    expect(messageFromHorizonUnknown(undefined)).toBe("");
-  });
-});
+  it('returns empty string for non-Error non-string', () => {
+    expect(messageFromHorizonUnknown({ code: 1 })).toBe('')
+    expect(messageFromHorizonUnknown(null)).toBe('')
+    expect(messageFromHorizonUnknown(undefined)).toBe('')
+  })
+})
 
-describe("throwHorizonLedgerOrOperationsError", () => {
-  const notFound = "ledger not found";
+describe('throwHorizonLedgerOrOperationsError', () => {
+  const notFound = 'ledger not found'
 
-  it("throws notFoundMessage for NotFoundError", () => {
+  it('throws notFoundMessage for NotFoundError', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new NotFoundError("gone", {}), notFound),
-    ).toThrow(notFound);
-  });
+      throwHorizonLedgerOrOperationsError(new NotFoundError('gone', {}), notFound)
+    ).toThrow(notFound)
+  })
 
-  it("throws notFoundMessage when message contains status code 404", () => {
+  it('throws notFoundMessage when message contains status code 404', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new Error("Request failed: status code 404"), notFound),
-    ).toThrow(notFound);
-  });
+      throwHorizonLedgerOrOperationsError(new Error('Request failed: status code 404'), notFound)
+    ).toThrow(notFound)
+  })
 
-  it("throws LedgerAPI4xx 429 for too many requests in message", () => {
+  it('throws notFoundMessage when Horizon problem body has status 404', () => {
+    const error = Object.assign(new Error('Request failed with status code 404'), {
+      response: {
+        data: {
+          title: 'Resource Missing',
+          status: 404,
+          detail: 'The resource at the url requested was not found.',
+        },
+      },
+    })
+    expect(() => throwHorizonLedgerOrOperationsError(error, notFound)).toThrow(notFound)
+  })
+
+  it('throws LedgerAPI4xx 429 for too many requests in message', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new Error("Too Many Requests"), notFound),
-    ).toThrow(LedgerAPI4xx);
-  });
+      throwHorizonLedgerOrOperationsError(new Error('Too Many Requests'), notFound)
+    ).toThrow(LedgerAPI4xx)
+  })
+
+  it('throws LedgerAPI4xx 429 when Horizon problem body has status 429', () => {
+    const error = Object.assign(new Error('Request failed with status code 429'), {
+      response: {
+        data: {
+          title: 'Rate Limited',
+          status: 429,
+          detail: 'The request was rate limited.',
+        },
+      },
+    })
+    expect(() => throwHorizonLedgerOrOperationsError(error, notFound)).toThrow(
+      expect.objectContaining({ name: 'LedgerAPI4xx', status: 429 })
+    )
+  })
 
-  it("throws LedgerAPI4xx for other 4xx status in message", () => {
+  it('throws LedgerAPI4xx for other 4xx status in message', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new Error("status code 400"), notFound),
-    ).toThrow(LedgerAPI4xx);
-  });
+      throwHorizonLedgerOrOperationsError(new Error('status code 400'), notFound)
+    ).toThrow(LedgerAPI4xx)
+  })
 
-  test.each([["401"], ["403"]])(
-    "throws LedgerAPI4xx when message contains status code %s",
-    code => {
+  it('throws LedgerAPI4xx when Horizon problem body has status 400', () => {
+    const error = Object.assign(new Error('Request failed with status code 400'), {
+      response: {
+        data: {
+          title: 'Bad Request',
+          status: 400,
+          detail: 'The request you sent was invalid in some way.',
+        },
+      },
+    })
+    expect(() => throwHorizonLedgerOrOperationsError(error, notFound)).toThrow(LedgerAPI4xx)
+  })
+
+  test.each([['401'], ['403']])(
+    'throws LedgerAPI4xx when message contains status code %s',
+    (code) => {
       expect(() =>
         throwHorizonLedgerOrOperationsError(
           new Error(`Request failed: status code ${code}`),
-          notFound,
-        ),
-      ).toThrow(LedgerAPI4xx);
-    },
-  );
+          notFound
+        )
+      ).toThrow(LedgerAPI4xx)
+    }
+  )
 
-  it("throws LedgerAPI5xx for 5xx status in message", () => {
+  it('throws LedgerAPI5xx for 5xx status in message', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new Error("status code 503"), notFound),
-    ).toThrow(LedgerAPI5xx);
-  });
+      throwHorizonLedgerOrOperationsError(new Error('status code 503'), notFound)
+    ).toThrow(LedgerAPI5xx)
+  })
 
-  test.each([["502"], ["500"]])(
-    "throws LedgerAPI5xx when message contains status code %s",
-    code => {
+  it('throws LedgerAPI5xx when Horizon problem body has status 503', () => {
+    const error = Object.assign(new Error('Request failed with status code 503'), {
+      response: {
+        data: {
+          title: 'Internal Server Error',
+          status: 503,
+          detail: 'An error occurred while processing this request.',
+        },
+      },
+    })
+    expect(() => throwHorizonLedgerOrOperationsError(error, notFound)).toThrow(LedgerAPI5xx)
+  })
+
+  test.each([['502'], ['500']])(
+    'throws LedgerAPI5xx when message contains status code %s',
+    (code) => {
       expect(() =>
-        throwHorizonLedgerOrOperationsError(new Error(`upstream status code ${code}`), notFound),
-      ).toThrow(LedgerAPI5xx);
-    },
-  );
+        throwHorizonLedgerOrOperationsError(new Error(`upstream status code ${code}`), notFound)
+      ).toThrow(LedgerAPI5xx)
+    }
+  )
 
-  it("throws NetworkDown for NetworkError", () => {
+  it('throws NetworkDown for NetworkError', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new NetworkError("net", {}), notFound),
-    ).toThrow(NetworkDown);
-  });
+      throwHorizonLedgerOrOperationsError(new NetworkError('net', {}), notFound)
+    ).toThrow(NetworkDown)
+  })
 
   test.each([
-    ["ECONNRESET", "ECONNRESET on read"],
-    ["ECONNREFUSED", "connect ECONNREFUSED 127.0.0.1:443"],
-    ["ENOTFOUND", "getaddrinfo ENOTFOUND horizon.example"],
-    ["EPIPE", "write EPIPE broken pipe"],
-    ["ETIMEDOUT", "connect ETIMEDOUT 10.0.0.1:443"],
-  ])("throws NetworkDown when message contains %s", (_label, message) => {
+    ['ECONNRESET', 'ECONNRESET on read'],
+    ['ECONNREFUSED', 'connect ECONNREFUSED 127.0.0.1:443'],
+    ['ENOTFOUND', 'getaddrinfo ENOTFOUND horizon.example'],
+    ['EPIPE', 'write EPIPE broken pipe'],
+    ['ETIMEDOUT', 'connect ETIMEDOUT 10.0.0.1:443'],
+  ])('throws NetworkDown when message contains %s', (_label, message) => {
     expect(() => throwHorizonLedgerOrOperationsError(new Error(message), notFound)).toThrow(
-      NetworkDown,
-    );
-  });
+      NetworkDown
+    )
+  })
 
-  it("throws NetworkDown for undefined is not an object in message", () => {
+  it('throws NetworkDown for undefined is not an object in message', () => {
     expect(() =>
-      throwHorizonLedgerOrOperationsError(new Error("undefined is not an object"), notFound),
-    ).toThrow(NetworkDown);
-  });
+      throwHorizonLedgerOrOperationsError(new Error('undefined is not an object'), notFound)
+    ).toThrow(NetworkDown)
+  })
 
-  it("rethrows unknown errors", () => {
-    const o = { custom: true };
+  it('rethrows unknown errors', () => {
+    const o = { custom: true }
     try {
-      throwHorizonLedgerOrOperationsError(o, notFound);
+      throwHorizonLedgerOrOperationsError(o, notFound)
     } catch (e) {
-      expect(e).toBe(o);
-      return;
+      expect(e).toBe(o)
+      return
     }
-    throw new Error("expected throw");
-  });
-});
+    throw new Error('expected throw')
+  })
+})

package/src/network/horizonLedgerErrors.ts

@@ -1,45 +1,72 @@
-import { LedgerAPI4xx, LedgerAPI5xx, NetworkDown } from "@ledgerhq/errors";
-import { NetworkError, NotFoundError } from "@stellar/stellar-sdk";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { LedgerAPI4xx, LedgerAPI5xx, NetworkDown } from '@ledgerhq/errors'
+import { NetworkError, NotFoundError } from '@stellar/stellar-sdk'
+import { documentationSummaryFromHorizonBody, getHorizonErrorBody } from './horizonErrorBody'
 
 export function messageFromHorizonUnknown(e: unknown): string {
+  const body = getHorizonErrorBody(e)
+  if (body) {
+    return documentationSummaryFromHorizonBody(body)
+  }
   if (e instanceof Error) {
-    return e.message;
+    return e.message
   }
-  if (typeof e === "string") {
-    return e;
+  if (typeof e === 'string') {
+    return e
   }
-  return "";
+  return ''
 }
 
-const HORIZON_STATUS_404 = /status code 404/;
-const HORIZON_TOO_MANY_REQUESTS = /too many requests/i;
-const HORIZON_STATUS_4XX = /status code 4\d{2}/;
-const HORIZON_STATUS_5XX = /status code 5\d{2}/;
-const HORIZON_NETWORK_DOWN = /ECONNRESET|ECONNREFUSED|ENOTFOUND|EPIPE|ETIMEDOUT/;
-const HORIZON_UNDEFINED_OBJECT = /undefined is not an object/;
+const HORIZON_STATUS_404 = /status code 404/
+const HORIZON_TOO_MANY_REQUESTS = /too many requests/i
+const HORIZON_STATUS_4XX = /status code 4\d{2}/
+const HORIZON_STATUS_5XX = /status code 5\d{2}/
+const HORIZON_NETWORK_DOWN = /ECONNRESET|ECONNREFUSED|ENOTFOUND|EPIPE|ETIMEDOUT/
+const HORIZON_UNDEFINED_OBJECT = /undefined is not an object/
 
 export function throwHorizonLedgerOrOperationsError(e: unknown, notFoundMessage: string): never {
-  const errorMsg = messageFromHorizonUnknown(e);
+  if (e instanceof NotFoundError) {
+    throw new Error(notFoundMessage)
+  }
+
+  const body = getHorizonErrorBody(e)
+  const status = body?.status
+  if (status === 404) {
+    throw new Error(notFoundMessage)
+  }
+  if (status === 429) {
+    throw new LedgerAPI4xx('status code 4xx', { status: 429, url: undefined, method: 'GET' })
+  }
+  if (status !== undefined && status >= 400 && status < 500) {
+    throw new LedgerAPI4xx()
+  }
+  if (status !== undefined && status >= 500 && status < 600) {
+    throw new LedgerAPI5xx()
+  }
+
+  const errorMsg = messageFromHorizonUnknown(e)
 
-  if (e instanceof NotFoundError || HORIZON_STATUS_404.exec(errorMsg)) {
-    throw new Error(notFoundMessage);
+  if (HORIZON_STATUS_404.exec(errorMsg)) {
+    throw new Error(notFoundMessage)
   }
   if (HORIZON_TOO_MANY_REQUESTS.exec(errorMsg)) {
-    throw new LedgerAPI4xx("status code 4xx", { status: 429, url: undefined, method: "GET" });
+    throw new LedgerAPI4xx('status code 4xx', { status: 429, url: undefined, method: 'GET' })
   }
   if (HORIZON_STATUS_4XX.exec(errorMsg)) {
-    throw new LedgerAPI4xx();
+    throw new LedgerAPI4xx()
   }
   if (HORIZON_STATUS_5XX.exec(errorMsg)) {
-    throw new LedgerAPI5xx();
+    throw new LedgerAPI5xx()
   }
   if (
     e instanceof NetworkError ||
     HORIZON_NETWORK_DOWN.exec(errorMsg) ||
     HORIZON_UNDEFINED_OBJECT.exec(errorMsg)
   ) {
-    throw new NetworkDown();
+    throw new NetworkDown()
   }
 
-  throw e;
+  throw e
 }

package/src/network/index.ts

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
 export {
   broadcastTransaction,
   fetchAccount,
@@ -13,4 +16,4 @@ export {
   getRecipientAccount,
   loadAccount,
   registerHorizonInterceptors,
-} from "./horizon";
+} from './horizon'