@lumenwipe/sdk 0.8.0 → 0.9.0

package/dist/index.js

@@ -60,6 +60,12 @@ var LumenWipeTimeoutError = class extends Error {
     this.name = "LumenWipeTimeoutError";
   }
 };
+var LumenWipeInvalidNetworkError = class extends Error {
+  constructor() {
+    super('LumenWipe network must be "mainnet" or "testnet"');
+    this.name = "LumenWipeInvalidNetworkError";
+  }
+};
 var LumenWipeAbortError = class extends Error {
   constructor(reason) {
     super("LumenWipe API request was aborted");
@@ -69,7 +75,7 @@ var LumenWipeAbortError = class extends Error {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.8.0";
+var SDK_VERSION = "0.9.0";
 
 // src/http.ts
 var MAX_DELAY_MS = 3e4;
@@ -84,11 +90,11 @@ var HttpTransport = class {
     this.retry = retry;
   }
   async request(method, path, body, opts) {
-    var _a, _b;
+    var _a, _b, _c;
     const attempts = opts.retry === "never" ? 1 : Math.max(1, Math.floor((_b = (_a = this.retry) == null ? void 0 : _a.attempts) != null ? _b : 1));
     for (let attempt = 1; ; attempt++) {
       try {
-        return await this.once(method, path, body, opts.signal);
+        return await this.once(method, path, body, (_c = opts.bearer) != null ? _c : this.apiKey, opts.signal);
       } catch (e) {
         if (attempt >= attempts || !this.shouldRetry(opts.retry, e)) throw e;
         await this.sleep(this.delayMs(e, attempt), opts.signal);
@@ -124,12 +130,11 @@ var HttpTransport = class {
       signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
     });
   }
-  async once(method, path, body, callerSignal) {
+  async once(method, path, body, bearer, callerSignal) {
     if (callerSignal == null ? void 0 : callerSignal.aborted) throw new LumenWipeAbortError(callerSignal.reason);
-    const headers = {
-      Authorization: `Bearer ${this.apiKey}`,
-      "X-LumenWipe-SDK": `sdk/${SDK_VERSION}`
-    };
+    const headers = {};
+    if (bearer !== void 0) headers.Authorization = `Bearer ${bearer}`;
+    headers["X-LumenWipe-SDK"] = `sdk/${SDK_VERSION}`;
     if (body !== void 0) headers["Content-Type"] = "application/json";
     const controller = new AbortController();
     let timedOut = false;
@@ -173,7 +178,16 @@ var HttpTransport = class {
   }
 };
 
+// src/url.ts
+var SLASH = 47;
+function withoutTrailingSlashes(url) {
+  let end = url.length;
+  while (end > 0 && url.charCodeAt(end - 1) === SLASH) end--;
+  return url.slice(0, end);
+}
+
 // src/client.ts
+var NETWORKS = ["mainnet", "testnet"];
 function isPlaintextRemote(baseUrl) {
   try {
     const url = new URL(baseUrl);
@@ -193,7 +207,7 @@ var LumenWipeClient = class {
       throw new Error("No fetch implementation available; pass one via options.fetch.");
     }
     this.http = new HttpTransport(
-      options.baseUrl.replace(/\/+$/, ""),
+      withoutTrailingSlashes(options.baseUrl),
       options.apiKey,
       (_b = options.timeout) != null ? _b : 3e4,
       resolved,
@@ -208,44 +222,78 @@ var LumenWipeClient = class {
     }
   }
   resolveNetwork(network) {
-    if (network) return network;
-    if (this.defaultNetwork) return this.defaultNetwork;
-    if (!this.warnedDefaultNetwork) {
-      this.warnedDefaultNetwork = true;
-      this.log(
-        'LumenWipe: no network given, defaulting to "testnet". Pass `network` to the client or the call to silence this.'
-      );
+    const resolved = network != null ? network : this.defaultNetwork;
+    if (resolved === void 0) {
+      if (!this.warnedDefaultNetwork) {
+        this.warnedDefaultNetwork = true;
+        this.log(
+          'LumenWipe: no network given, defaulting to "testnet". Pass `network` to the client or the call to silence this.'
+        );
+      }
+      return "testnet";
     }
-    return "testnet";
+    if (!NETWORKS.includes(resolved)) throw new LumenWipeInvalidNetworkError();
+    return resolved;
+  }
+  /** The `/v1/{network}` path for `rest`. The network is checked before any request is built. */
+  v1(network, rest) {
+    return `/v1/${encodeURIComponent(this.resolveNetwork(network))}${rest}`;
   }
   health(options) {
     return this.http.request("GET", "/health", void 0, __spreadProps(__spreadValues({}, options), {
       retry: "transient"
     }));
   }
-  getAccount(address, network, options) {
+  /** Whether Stellar RPC is reachable on every network, and the days left on the exchange registry.
+   *  A degraded service answers 503, thrown as a `LumenWipeApiError` whose `body` is a
+   *  `HealthDeepResponse` with `status: "error"`. Never retried: the 503 is the answer. */
+  healthDeep(options) {
+    return this.http.request("GET", "/health/deep", void 0, __spreadProps(__spreadValues({}, options), {
+      retry: "never"
+    }));
+  }
+  /** The exchange registry the API closes against. Do not rely on it past `validUntil`. */
+  getExchangeRegistry(options) {
+    return this.http.request(
+      "GET",
+      "/v1/config/exchange-registry",
+      void 0,
+      __spreadProps(__spreadValues({}, options), { retry: "transient" })
+    );
+  }
+  async getAccount(address, network, options) {
     return this.http.request(
       "GET",
-      `/${this.resolveNetwork(network)}/account/${encodeURIComponent(address)}`,
+      this.v1(network, `/account/${encodeURIComponent(address)}`),
       void 0,
       __spreadProps(__spreadValues({}, options), { retry: "transient" })
     );
   }
-  getPaths(params, network, options) {
+  async getPaths(params, network, options) {
     const query = new URLSearchParams({ fromAsset: params.fromAsset, amount: params.amount });
     return this.http.request(
       "GET",
-      `/${this.resolveNetwork(network)}/paths?${query.toString()}`,
+      this.v1(network, `/paths?${query.toString()}`),
       void 0,
       __spreadProps(__spreadValues({}, options), { retry: "transient" })
     );
   }
-  closePlan(body, network, options) {
+  async closePlan(body, network, options) {
+    return this.http.request("POST", this.v1(network, "/close/plan"), body, __spreadProps(__spreadValues({}, options), {
+      retry: "throttle"
+    }));
+  }
+  /** Plans up to 20 accounts into one shared destination in one call. Read-only: no decisions are
+   *  applied, so plan each account with `closePlan` before closing it. An address that cannot be
+   *  read or planned comes back as a `blocked` plan, never as a missing entry. */
+  async batchPlan(body, network, options) {
     return this.http.request(
       "POST",
-      `/v1/${this.resolveNetwork(network)}/close/plan`,
+      this.v1(network, "/close/batch-plan"),
       body,
-      __spreadProps(__spreadValues({}, options), { retry: "throttle" })
+      __spreadProps(__spreadValues({}, options), {
+        retry: "throttle"
+      })
     );
   }
   /**
@@ -255,34 +303,68 @@ var LumenWipeClient = class {
    * submit the returned transactions in `order`, wait for confirmation, then call this
    * again until `requiresAnotherCall` is false.
    */
-  closeTransactions(body, network, options) {
+  async closeTransactions(body, network, options) {
     return this.http.request(
       "POST",
-      `/v1/${this.resolveNetwork(network)}/close/transactions`,
+      this.v1(network, "/close/transactions"),
       body,
       __spreadProps(__spreadValues({}, options), { retry: "throttle" })
     );
   }
-  submit(signedXdr, network, options) {
+  async submit(signedXdr, network, options) {
     return this.http.request(
       "POST",
-      `/v1/${this.resolveNetwork(network)}/submit`,
+      this.v1(network, "/submit"),
       { signedXdr },
       __spreadProps(__spreadValues({}, options), { retry: "never" })
     );
   }
-  mediatorCheck(address, network, options) {
+  /** Looks a transaction up by hash and sends nothing. `not_found` is not "did not land": the
+   *  transaction may be queued, or older than the window the response names. */
+  async getTransaction(hash, network, options) {
+    return this.http.request(
+      "GET",
+      this.v1(network, `/transactions/${encodeURIComponent(hash)}`),
+      void 0,
+      __spreadProps(__spreadValues({}, options), { retry: "transient" })
+    );
+  }
+  /** A close's phase and remaining work, from live state. Informational: a close is finished only
+   *  when the hash of the merge you signed is confirmed by `getTransaction`. */
+  async closeStatus(source, network, options) {
+    const query = new URLSearchParams({ source });
     return this.http.request(
       "GET",
-      `/${this.resolveNetwork(network)}/mediator/check/${encodeURIComponent(address)}`,
+      this.v1(network, `/close/status?${query.toString()}`),
       void 0,
       __spreadProps(__spreadValues({}, options), { retry: "transient" })
     );
   }
-  mediatorSign(transaction, network, options) {
+  /** The XLM confirmed close transactions delivered to `destination`, read from each one's ledger
+   *  result: a merge into it, or the relay account's forward of a merged balance. A hash that
+   *  cannot be read as delivered is an `unavailable` entry, not an error, and `totalStroops` is
+   *  set only when every entry is `delivered`. Pass 1 to 20 distinct hashes. */
+  async closeDelivered(destination, hashes, network, options) {
+    const query = new URLSearchParams({ destination, hashes: hashes.join(",") });
+    return this.http.request(
+      "GET",
+      this.v1(network, `/close/delivered?${query.toString()}`),
+      void 0,
+      __spreadProps(__spreadValues({}, options), { retry: "transient" })
+    );
+  }
+  async mediatorCheck(address, network, options) {
+    return this.http.request(
+      "GET",
+      this.v1(network, `/mediator/check/${encodeURIComponent(address)}`),
+      void 0,
+      __spreadProps(__spreadValues({}, options), { retry: "transient" })
+    );
+  }
+  async mediatorSign(transaction, network, options) {
     return this.http.request(
       "POST",
-      `/${this.resolveNetwork(network)}/mediator/sign`,
+      this.v1(network, "/mediator/sign"),
       {
         transaction
       },
@@ -292,10 +374,10 @@ var LumenWipeClient = class {
   /** Wraps a wind-down transaction (its own fee already zero) in a signed CAP-15 fee-bump
    *  envelope for an account that cannot pay its own fee (architecture.md §8.1). The caller
    *  submits the returned XDR through `submit()`, exactly like any other close transaction. */
-  feeBumpSponsor(transaction, network, options) {
+  async feeBumpSponsor(transaction, network, options) {
     return this.http.request(
       "POST",
-      `/${this.resolveNetwork(network)}/fee-bump/sponsor`,
+      this.v1(network, "/fee-bump/sponsor"),
       {
         transaction
       },
@@ -304,24 +386,125 @@ var LumenWipeClient = class {
   }
   /** Every live SEP-41 allowance the account has granted (architecture.md §12). Independent of
    *  closing an account - a standalone security utility. */
-  getAllowances(address, network, options) {
+  async getAllowances(address, network, options) {
     return this.http.request(
       "GET",
-      `/${this.resolveNetwork(network)}/allowances/${encodeURIComponent(address)}`,
+      this.v1(network, `/allowances/${encodeURIComponent(address)}`),
       void 0,
       __spreadProps(__spreadValues({}, options), { retry: "transient" })
     );
   }
   /** Builds the unsigned `approve(owner, spender, 0, 0)` transaction that revokes one allowance.
    *  The caller signs and submits it through `submit()`, like any other transaction here. */
-  revokeAllowance(params, network, options) {
+  async revokeAllowance(params, network, options) {
     return this.http.request(
       "POST",
-      `/${this.resolveNetwork(network)}/allowances/revoke`,
+      this.v1(network, "/allowances/revoke"),
       params,
       __spreadProps(__spreadValues({}, options), { retry: "throttle" })
     );
   }
+  /** Accounts closed and XLM recovered through LumenWipe on the network. */
+  async getStats(network, options) {
+    return this.http.request("GET", this.v1(network, "/stats"), void 0, __spreadProps(__spreadValues({}, options), {
+      retry: "transient"
+    }));
+  }
+  /** The totals, the most recent closes and the daily activity on the network. */
+  async getStatsFeed(network, options) {
+    return this.http.request("GET", this.v1(network, "/stats/feed"), void 0, __spreadProps(__spreadValues({}, options), {
+      retry: "transient"
+    }));
+  }
+  /** Counts a confirmed close that was submitted outside this API. The API re-reads the
+   *  transaction and counts it only if it built it, it confirmed and it merged an account;
+   *  `counted` is false for a hash already counted. Closes sent through `submit()` are counted
+   *  without this. */
+  async recordMerge(txHash, network, options) {
+    return this.http.request(
+      "POST",
+      this.v1(network, "/stats/merges"),
+      { txHash },
+      __spreadProps(__spreadValues({}, options), { retry: "throttle" })
+    );
+  }
+};
+
+// src/integrator-client.ts
+var LumenWipeIntegratorClient = class {
+  constructor(options) {
+    var _a, _b, _c;
+    const resolved = (_a = options.fetch) != null ? _a : globalThis.fetch;
+    if (!resolved) {
+      throw new Error("No fetch implementation available; pass one via options.fetch.");
+    }
+    this.http = new HttpTransport(
+      withoutTrailingSlashes(options.baseUrl),
+      void 0,
+      (_b = options.timeout) != null ? _b : 3e4,
+      resolved,
+      options.retry
+    );
+    if (isPlaintextRemote(options.baseUrl)) {
+      ((_c = options.logger) != null ? _c : ((message) => console.warn(message)))(
+        "LumenWipe: baseUrl uses http:// for a non-local host. Session tokens and new keys travel in clear text; use https://."
+      );
+    }
+  }
+  /** A SEP-53 message for `address` (G...) to sign, valid until `expiresAt`. */
+  challenge(address, options) {
+    return this.http.request(
+      "POST",
+      "/v1/integrator/auth/challenge",
+      { address },
+      __spreadProps(__spreadValues({}, options), { retry: "throttle" })
+    );
+  }
+  /** Exchanges the signed challenge for a session token. */
+  session(request, options) {
+    return this.http.request(
+      "POST",
+      "/v1/integrator/auth/session",
+      { address: request.address, message: request.message, signature: request.signature },
+      __spreadProps(__spreadValues({}, options), { retry: "throttle" })
+    );
+  }
+  /** The wallet's keys, each with its own request counts, and the wallet's total counts. */
+  listKeys(token, options) {
+    return this.http.request("GET", "/v1/integrator/keys", void 0, __spreadProps(__spreadValues({}, options), {
+      retry: "transient",
+      bearer: token
+    }));
+  }
+  /** Creates a key, optionally named and limited to some networks. The raw `key` is in this
+   *  response only and can never be read again. */
+  createKey(token, request = {}, options) {
+    return this.http.request(
+      "POST",
+      "/v1/integrator/keys",
+      { label: request.label, networks: request.networks },
+      __spreadProps(__spreadValues({}, options), { retry: "never", bearer: token })
+    );
+  }
+  /** Revokes one of the wallet's keys by its `id`. */
+  revokeKey(token, id, options) {
+    return this.http.request(
+      "POST",
+      `/v1/integrator/keys/${encodeURIComponent(id)}/revoke`,
+      void 0,
+      __spreadProps(__spreadValues({}, options), { retry: "never", bearer: token })
+    );
+  }
+  /** Revokes a key and issues its replacement, keeping its label and networks. The new raw `key`
+   *  is in this response only. */
+  rotateKey(token, id, options) {
+    return this.http.request(
+      "POST",
+      `/v1/integrator/keys/${encodeURIComponent(id)}/rotate`,
+      void 0,
+      __spreadProps(__spreadValues({}, options), { retry: "never", bearer: token })
+    );
+  }
 };
 
 // src/close-engine.ts
@@ -334,33 +517,200 @@ var InsufficientSignatureWeightError = class extends Error {
     this.name = "InsufficientSignatureWeightError";
   }
 };
+var STATE_CHANGED_REFETCHES = 2;
+var STATE_CHANGED_REFETCH_DELAY_MS = 3e3;
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var CloseStateChangedError = class extends Error {
+  constructor(apiError) {
+    super(
+      "Your account changed while the close was being prepared, so nothing was submitted. Plan the close again and review it before continuing."
+    );
+    this.apiError = apiError;
+    this.name = "CloseStateChangedError";
+  }
+};
+function hasCode(error, code) {
+  return typeof error === "object" && error !== null && error.code === code;
+}
+var SUBMIT_RESEND_ATTEMPTS = 2;
+var SUBMIT_RESEND_DELAY_MS = 5e3;
+var SUBMISSION_GIVE_UP_MARGIN_SECONDS = 120;
+var CloseOutcomeUnknownError = class extends Error {
+  constructor(submission) {
+    super(
+      "This transaction is not confirmed yet. Your account may already be closed, so check again before doing anything else."
+    );
+    this.submission = submission;
+    this.name = "CloseOutcomeUnknownError";
+  }
+};
+var CloseTransactionFailedError = class extends Error {
+  constructor(submission, message) {
+    super(message);
+    this.submission = submission;
+    this.name = "CloseTransactionFailedError";
+  }
+};
+function isSubmitRefused(error) {
+  const status = error == null ? void 0 : error.status;
+  return typeof status === "number" && status >= 400 && status < 500;
+}
+async function resolveSubmission(submission, lookup, now = Date.now) {
+  let found;
+  try {
+    found = await lookup(submission.hash);
+  } catch (e) {
+    return { outcome: "unknown" };
+  }
+  if (found.hash !== submission.hash) return { outcome: "unknown" };
+  if (found.status === "confirmed") return { outcome: "confirmed" };
+  if (found.status === "failed") return { outcome: "failed", message: found.message };
+  if (submission.validUntil === null) return { outcome: "unknown" };
+  const elapsed = Math.min(now() / 1e3, found.searched.latestLedgerCloseTime);
+  return elapsed > submission.validUntil + SUBMISSION_GIVE_UP_MARGIN_SECONDS ? { outcome: "expired" } : { outcome: "unknown" };
+}
+var submissionClosesAccount = (submission) => submission.covers.some((step) => step === "MERGE" || step === "CLOSE_ACCOUNT");
+var ROUND_MARGIN = 5;
+var HARD_MAX_ROUNDS = 200;
+var CloseDidNotConvergeError = class extends Error {
+  constructor(rounds, bound, reason) {
+    super(
+      reason === "empty_batch" ? "The close stopped because the service reported more steps but had nothing to sign. Check your account, then try again - the close picks up where it stopped." : `The close needed more steps than expected (${rounds} of at most ${bound}). Check your account, then try again - the close picks up where it stopped.`
+    );
+    this.rounds = rounds;
+    this.bound = bound;
+    this.reason = reason;
+    this.name = "CloseDidNotConvergeError";
+  }
+};
 async function runClose(deps, resume) {
-  var _a, _b;
-  const maxRounds = (_a = deps.maxRounds) != null ? _a : 25;
+  var _a, _b, _c, _d, _e, _f;
+  let bound = 0;
+  let planHash = resume ? void 0 : deps.planHash;
+  const run = __spreadProps(__spreadValues({}, deps), {
+    onConfirmed: (tx, hash) => {
+      var _a2;
+      planHash = void 0;
+      (_a2 = deps.onConfirmed) == null ? void 0 : _a2.call(deps, tx, hash);
+    }
+  });
+  if ((_a = deps.reconcile) == null ? void 0 : _a.unresolved) {
+    const settled = await settleLeftOver(deps.reconcile, deps.reconcile.unresolved);
+    if (settled === "closed") return { mergeConfirmed: true };
+    if (settled === "confirmed") planHash = void 0;
+  }
+  let firstRound = 0;
   if (resume) {
-    await signOrThrow(deps, resume.tx, resume.xdr, resume.queue, resume.requiresAnotherCall);
-    await processTxs(deps, resume.queue, resume.requiresAnotherCall);
-    if (!resume.requiresAnotherCall) return;
+    const at = resumedPosition(resume);
+    firstRound = at.round + 1;
+    await signOrThrow(run, resume.tx, resume.xdr, resume.queue, at);
+    await processTxs(run, resume.queue, __spreadProps(__spreadValues({}, at), { txIndex: at.txIndex + 1 }));
+    if (!resume.requiresAnotherCall) return resultOf(run);
   }
-  for (let round = 0; round < maxRounds; round++) {
-    (_b = deps.onProgress) == null ? void 0 : _b.call(deps, "Preparing transactions\u2026");
-    const batch = await deps.getTransactions();
+  for (let round = 0; round < ((_b = run.maxRounds) != null ? _b : Math.max(bound, 1)); round++) {
+    (_c = run.onProgress) == null ? void 0 : _c.call(run, "Preparing transactions\u2026");
+    report(run, () => ({ phase: "preparing", round: firstRound + round }));
+    const batch = await fetchRound(run, planHash).catch(async (error) => {
+      if (await mergeExplainsMissingAccount(run, error)) return null;
+      throw error;
+    });
+    if (!batch) return resultOf(run);
     const txs = [...batch.transactions].sort((a, b) => a.order - b.order);
-    await processTxs(deps, txs, batch.remaining.requiresAnotherCall);
-    if (!batch.remaining.requiresAnotherCall) return;
+    const { requiresAnotherCall, steps } = batch.remaining;
+    if (requiresAnotherCall && txs.length === 0) {
+      throw new CloseDidNotConvergeError(round + 1, (_d = run.maxRounds) != null ? _d : bound, "empty_batch");
+    }
+    await processTxs(run, txs, {
+      round: firstRound + round,
+      txIndex: 0,
+      txCount: txs.length,
+      moreRoundsExpected: requiresAnotherCall
+    });
+    if (!requiresAnotherCall) return resultOf(run);
+    bound = Math.max(bound, Math.min(HARD_MAX_ROUNDS, round + 1 + steps + ROUND_MARGIN));
   }
-  throw new Error("The close did not converge after the maximum number of rounds.");
+  throw new CloseDidNotConvergeError((_e = run.maxRounds) != null ? _e : bound, (_f = run.maxRounds) != null ? _f : bound, "round_limit");
+}
+function resultOf(run) {
+  return { mergeConfirmed: run.confirmedMerge !== void 0 };
 }
-async function processTxs(deps, txs, requiresAnotherCall) {
+async function settleLeftOver(reconcile, submission) {
+  var _a, _b;
+  const settled = await resolveSubmission(submission, reconcile.lookup, reconcile.now);
+  if (settled.outcome === "unknown") throw new CloseOutcomeUnknownError(submission);
+  await ((_a = reconcile.onSubmission) == null ? void 0 : _a.call(reconcile, null));
+  if (settled.outcome === "failed") {
+    throw new CloseTransactionFailedError(submission, settled.message);
+  }
+  if (settled.outcome === "expired") return "expired";
+  (_b = reconcile.onResolved) == null ? void 0 : _b.call(reconcile, submission);
+  return submissionClosesAccount(submission) ? "closed" : "confirmed";
+}
+async function mergeExplainsMissingAccount(run, error) {
+  if (!hasCode(error, "account_not_found") || !run.reconcile || !run.confirmedMerge) return false;
+  const settled = await resolveSubmission(
+    run.confirmedMerge,
+    run.reconcile.lookup,
+    run.reconcile.now
+  );
+  return settled.outcome === "confirmed";
+}
+async function fetchRound(deps, planHash) {
+  var _a;
+  for (let attempt = 0; ; attempt++) {
+    if (attempt > 0) await ((_a = deps.sleep) != null ? _a : defaultSleep)(STATE_CHANGED_REFETCH_DELAY_MS);
+    try {
+      return await deps.getTransactions(planHash === void 0 ? {} : { planHash });
+    } catch (error) {
+      if (!hasCode(error, "state_changed")) throw error;
+      if (planHash !== void 0 || attempt === STATE_CHANGED_REFETCHES) {
+        throw new CloseStateChangedError(error);
+      }
+    }
+  }
+}
+function resumedPosition(resume) {
+  var _a, _b, _c;
+  const txIndex = (_a = resume.txIndex) != null ? _a : 0;
+  return {
+    round: (_b = resume.round) != null ? _b : 0,
+    txIndex,
+    txCount: (_c = resume.txCount) != null ? _c : txIndex + 1 + resume.queue.length,
+    moreRoundsExpected: resume.requiresAnotherCall
+  };
+}
+function report(deps, build) {
+  if (!deps.onProgressEvent) return;
+  try {
+    const returned = deps.onProgressEvent(build());
+    if (returned instanceof Promise) returned.catch(() => {
+    });
+  } catch (e) {
+  }
+}
+function reportTx(deps, phase, at, covers) {
+  report(deps, () => ({
+    phase,
+    round: at.round,
+    txIndex: at.txIndex,
+    txCount: at.txCount,
+    covers: [...covers],
+    moreRoundsExpected: at.moreRoundsExpected
+  }));
+}
+async function processTxs(deps, txs, start) {
   for (let i = 0; i < txs.length; i++) {
     const tx = txs[i];
+    const at = __spreadProps(__spreadValues({}, start), { txIndex: start.txIndex + i });
+    reportTx(deps, "verifying", at, tx.covers);
     await deps.verify(tx);
-    await signOrThrow(deps, tx, tx.xdr, txs.slice(i + 1), requiresAnotherCall);
+    await signOrThrow(deps, tx, tx.xdr, txs.slice(i + 1), at);
   }
 }
-async function signOrThrow(deps, tx, xdr, queue, requiresAnotherCall) {
-  var _a;
+async function signOrThrow(deps, tx, xdr, queue, at) {
+  var _a, _b, _c, _d, _e, _f;
   const required = deps.requiredWeight(tx);
+  reportTx(deps, "awaiting-signature", at, tx.covers);
   const { xdr: signedXdr, weight } = await deps.sign(tx, xdr);
   if (weight < required) {
     throw new InsufficientSignatureWeightError({
@@ -369,18 +719,81 @@ async function signOrThrow(deps, tx, xdr, queue, requiresAnotherCall) {
       requiredWeight: required,
       accumulatedWeight: weight,
       queue,
-      requiresAnotherCall
+      requiresAnotherCall: at.moreRoundsExpected,
+      round: at.round,
+      txIndex: at.txIndex,
+      txCount: at.txCount
     });
   }
-  const hash = await deps.submit(tx, signedXdr);
-  (_a = deps.onConfirmed) == null ? void 0 : _a.call(deps, tx, hash);
+  reportTx(deps, "submitting", at, tx.covers);
+  const finalXdr = deps.prepare ? await deps.prepare(tx, signedXdr) : signedXdr;
+  if (!deps.reconcile) {
+    (_a = deps.onConfirmed) == null ? void 0 : _a.call(deps, tx, await deps.submit(tx, finalXdr));
+    reportTx(deps, "confirmed", at, tx.covers);
+    return;
+  }
+  const submission = openSubmission(deps.reconcile, tx, finalXdr);
+  await ((_c = (_b = deps.reconcile).onSubmission) == null ? void 0 : _c.call(_b, submission));
+  await submitUntilSettled(deps, deps.reconcile, tx, finalXdr, submission);
+  await ((_e = (_d = deps.reconcile).onSubmission) == null ? void 0 : _e.call(_d, null));
+  if (submissionClosesAccount(submission)) deps.confirmedMerge = submission;
+  (_f = deps.onConfirmed) == null ? void 0 : _f.call(deps, __spreadProps(__spreadValues({}, tx), { covers: submission.covers }), submission.hash);
+  reportTx(deps, "confirmed", at, submission.covers);
+}
+function openSubmission(reconcile, tx, finalXdr) {
+  const claimed = tx.covers.filter((s) => s !== "MERGE" && s !== "CLOSE_ACCOUNT");
+  return __spreadValues(__spreadValues({
+    hash: reconcile.hashOf(finalXdr),
+    covers: reconcile.closesAccount(finalXdr) ? [...claimed, "MERGE", "CLOSE_ACCOUNT"] : claimed,
+    validUntil: reconcile.validUntil(finalXdr)
+  }, tx.coversTargets && { coversTargets: tx.coversTargets }), tx.needsSponsoredFee && { needsSponsoredFee: true });
+}
+async function submitUntilSettled(deps, reconcile, tx, finalXdr, submission) {
+  var _a, _b, _c, _d;
+  for (let attempt = 0; attempt <= SUBMIT_RESEND_ATTEMPTS; attempt++) {
+    if (attempt > 0) {
+      (_a = deps.onProgress) == null ? void 0 : _a.call(deps, "Still waiting for the network to confirm\u2026");
+      await ((_b = deps.sleep) != null ? _b : defaultSleep)(SUBMIT_RESEND_DELAY_MS);
+    }
+    try {
+      if (await deps.submit(tx, finalXdr) === submission.hash) return;
+    } catch (error) {
+      if (!isSubmitRefused(error)) continue;
+      if (attempt === 0) {
+        await ((_c = reconcile.onSubmission) == null ? void 0 : _c.call(reconcile, null));
+        throw error;
+      }
+      break;
+    }
+  }
+  const settled = await resolveSubmission(submission, reconcile.lookup, reconcile.now);
+  if (settled.outcome === "confirmed") return;
+  if (settled.outcome === "failed") {
+    await ((_d = reconcile.onSubmission) == null ? void 0 : _d.call(reconcile, null));
+    throw new CloseTransactionFailedError(submission, settled.message);
+  }
+  throw new CloseOutcomeUnknownError(submission);
 }
 export {
+  CloseDidNotConvergeError,
+  CloseOutcomeUnknownError,
+  CloseStateChangedError,
+  CloseTransactionFailedError,
   InsufficientSignatureWeightError,
   LumenWipeAbortError,
   LumenWipeApiError,
   LumenWipeClient,
+  LumenWipeIntegratorClient,
+  LumenWipeInvalidNetworkError,
   LumenWipeTimeoutError,
+  STATE_CHANGED_REFETCHES,
+  STATE_CHANGED_REFETCH_DELAY_MS,
+  SUBMISSION_GIVE_UP_MARGIN_SECONDS,
+  SUBMIT_RESEND_ATTEMPTS,
+  SUBMIT_RESEND_DELAY_MS,
   isApiErrorCode,
-  runClose
+  isSubmitRefused,
+  resolveSubmission,
+  runClose,
+  submissionClosesAccount
 };