For small teams that wantto ship fast, safely.

 import { BankError } from "./errors";
+import { sleep } from "../util/sleep";
 
 export interface RetryOptions {
   attempts: number;
+  /** The first wait, doubled each time the bank says no. */
+  baseMs: number;
+  /** Never wait longer than this, whatever Retry-After says. */
+  maxMs: number;
 }

vida First the options: a starting wait and a ceiling, so a long Retry-After cannot stall the nightly sync.

+export function backoff(err: unknown, attempt: number, opts: RetryOptions): number {
+  const header = err instanceof BankError ? err.headers.get("retry-after") : null;
+  const asked = header ? Number(header) * 1000 : NaN;
+  const ours = opts.baseMs * 2 ** attempt;
+  return Math.min(Number.isFinite(asked) ? asked : ours, opts.maxMs);
+}

vida Then the wait: the bank's Retry-After when it sends one, otherwise doubling from the start, never past the ceiling.

     } catch (err) {
       last = err;
+      if (!(err instanceof BankError) || err.status !== 429) throw err;
+      await sleep(backoff(err, i, opts));
     }

vida And the loop only retries a 429 now. Any other error is thrown at once instead of being retried.

-export const bank = (call) => withRetry(call, { attempts: 3 });
+export const bank = (call) => withRetry(call, { attempts: 5, baseMs: 500, maxMs: 30_000 });

vida The bank client sets it up: five attempts, starting at half a second, never waiting past thirty.

+test("honours Retry-After when the bank sends one", () => {
+  const err = rateLimited({ "retry-after": "4" });
+  assert.equal(backoff(err, 0, { attempts: 5, baseMs: 500, maxMs: 30_000 }), 4000);
+});
+
+test("doubles its own wait otherwise, up to the cap", () => {
+  const err = rateLimited({});
+  assert.equal(backoff(err, 3, { attempts: 5, baseMs: 500, maxMs: 3000 }), 3000);
+});

vida A test for each path: the bank's Retry-After is honoured, and our own wait stops at the ceiling.

-Runs nightly at 02:00 and retries three times.
+Runs nightly at 02:00. On a 429 it waits for the bank's Retry-After,
+or doubles its own wait from 500 ms, up to 30 s, five attempts in all.

vida Last, the sync doc says what it does now, so the next person does not have to read the code to find out.