@invisible-labs/sdk 0.6.0-devnet.3 → 0.6.0-devnet.5

package/dist/user.js

@@ -1,12 +1,13 @@
-import { scheduledPayoutWindowSeconds } from './chunk-NKRVQXRP.js';
-import { validatePayoutPolicyShape, formatAjvErrors, createSession, createExponentialBackoff } from './chunk-BWCGNTN5.js';
+import { scheduledPayoutWindowSeconds } from './chunk-3TGQ4CZ3.js';
+import { validatePayoutPolicyShape, formatAjvErrors, persistTransferStatus, createSession, disabledClientPersistence, readPersistedTransferForResume, persistTransferReady, createExponentialBackoff, persistTransferTerminal, persistTransferRecoveryCode, persistTransferAllocation, persistTransferDkgMetadata } from './chunk-Y7AK6RBV.js';
+export { getPersistedTransfer, listPersistedTransfers, purgePersistedTransfers, removePersistedTransfer } from './chunk-Y7AK6RBV.js';
 import { PRODUCT_MAX_ENTRY_LAMPORTS, PRODUCT_MIN_ENTRY_LAMPORTS } from './chunk-4X5OCCQW.js';
-import { assertAttested, publicKey, solanaAddressFromPublicKeyBytes } from './chunk-NHEHCUS5.js';
-import { requestEnvelope, CoordinatorMessageType, onEnvelope, closeProtocolRuntime, EnvelopeKind } from './chunk-QQSI3ZD7.js';
-import { getSessionState } from './chunk-V5HXJRBW.js';
-import './chunk-DIA6U2CV.js';
-import { PolicyValidationError, CommandError, TransportError, InvalidDepositAmountError, normalizeError, RoutingError, AttestationError } from './chunk-GHBQF3A7.js';
-export { InvalidDepositAmountError } from './chunk-GHBQF3A7.js';
+import { assertAttested, publicKey, solanaAddressFromPublicKeyBytes } from './chunk-EBWTAXNT.js';
+import { requestEnvelope, CoordinatorMessageType, onEnvelope, closeProtocolRuntime, EnvelopeKind } from './chunk-3MDHAS4D.js';
+import { getSessionState } from './chunk-HJFMDMPY.js';
+import './chunk-DCTYBUY3.js';
+import { PolicyValidationError, CommandError, StorageError, TransportError, normalizeError, InvalidDepositAmountError, AttestationError, RoutingError } from './chunk-QRN46R3F.js';
+export { InvalidDepositAmountError } from './chunk-QRN46R3F.js';
 import './chunk-VR6T6OJS.js';
 
 // src/validation/payoutPolicy.ts
@@ -171,7 +172,7 @@ function recoveryCodeFromUserInput(input) {
 var protocolPromise = null;
 var frostRuntimePromise = null;
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-VVJ33WF2.js');
+  protocolPromise ??= import('./coordinator-PEWHNZ7I.js');
   return protocolPromise;
 }
 function loadFrostRuntime() {
@@ -185,20 +186,22 @@ var BENIGN_TRANSPORT_DROP = /* @__PURE__ */ Symbol("benignTransportDrop");
 var ALICE_ID = 1;
 var COORDINATOR_ID = 2;
 var SYNC_SECRET_BYTE_LENGTH = 32;
+var RESUME_SECRET_BYTE_LENGTH = SYNC_SECRET_BYTE_LENGTH;
 var SYNC_CONTRACT_ID_MISMATCH_MESSAGE = "sync response contract id does not match requested contract";
-var ACTIVE_CONTRACT_REQUEST_MESSAGE = "coordinator session already has an active contract";
 var DEFAULT_SWAP_STATUS_RECONCILE_INTERVAL_MS = 5e3;
 var MAX_SWAP_STATUS_RETRY_DELAY_MS = 3e4;
 var SWAP_STATUS_RETRY_MULTIPLIER = 2;
+var MAX_EVENT_DEDUP_ENTRIES_PER_KIND = 1024;
 var SWAP_STATUS_RETRY_JITTER_RATIO = 0.2;
 var DEFAULT_REFUND_OUTCOME_POLL_BUDGET_MS = 5 * 60 * 1e3;
 var REFUND_OUTCOME_POLL_INTERVAL_MS = 3e3;
 var REFUND_OUTCOME_PER_POLL_TIMEOUT_MS = 5e3;
+var UNBOUND_RECONCILIATION_KEY = "__unbound__";
 var REQUEST_TIMEOUT_MESSAGE = "coordinator request timed out";
+var REFUND_PENDING_FINALIZATION_MESSAGE = "refund accepted and pending finalization; check status again shortly";
 var CURRENT_SCHEDULED_PAYOUT_WINDOW_SECONDS = new Set(scheduledPayoutWindowSeconds());
 var CURRENT_SCHEDULED_PAYOUT_WINDOW_MESSAGE = `scheduled payout_spec.window_seconds must be one of [${scheduledPayoutWindowSeconds().join(", ")}]`;
 var TERMINAL_SWAP_STATES = /* @__PURE__ */ new Set(["completed", "refunded", "failed"]);
-var activeFunctionalContractRequests = /* @__PURE__ */ new WeakSet();
 function isBenignTransportDrop(err) {
   return typeof err === "object" && err !== null && err[BENIGN_TRANSPORT_DROP] === true;
 }
@@ -210,6 +213,16 @@ function readDkgComplete(protocol, envelope) {
     coordinatorTimestampMs: envelope.timestamp_ms
   };
 }
+function assertDepositConfirmedAmount(protocol, envelope, expectedAmountLamports) {
+  const payload = protocol.asDepositConfirmedPayload(envelope);
+  if (payload.amount_lamports !== expectedAmountLamports) {
+    throw new InvalidDepositAmountError(
+      BigInt(payload.amount_lamports),
+      BigInt(expectedAmountLamports)
+    );
+  }
+  return payload;
+}
 function tagBenignTransportDrop(err) {
   err[BENIGN_TRANSPORT_DROP] = true;
   return err;
@@ -227,22 +240,27 @@ var UserCoordinatorSession = class {
     this.sessionStatus = "idle";
     this.swapId = null;
     this.syncSecret = null;
+    this.resumeSecret = null;
     this.attested = false;
     this.pushListeners = /* @__PURE__ */ new Map();
+    this.swapContexts = /* @__PURE__ */ new Map();
+    this.openingSession = null;
+    this.activeOperations = 0;
     this.stateListeners = /* @__PURE__ */ new Set();
     this.logListeners = /* @__PURE__ */ new Set();
     this.payoutExecutedListeners = /* @__PURE__ */ new Set();
     this.refundExecutedListeners = /* @__PURE__ */ new Set();
     this.normalUserActorSyncListeners = /* @__PURE__ */ new Set();
     this.coordinatorErrorListeners = /* @__PURE__ */ new Set();
+    this.storageErrorListeners = /* @__PURE__ */ new Set();
     this.emittedPayoutKeys = /* @__PURE__ */ new Set();
     this.emittedRefundKeys = /* @__PURE__ */ new Set();
-    this.stopStatusReconciliation = null;
-    this.bufferDepositConfirmedUntilDelegateAck = false;
-    this.bufferedDepositConfirmed = null;
+    this.statusReconciliationStops = /* @__PURE__ */ new Map();
+    this.pushProcessing = /* @__PURE__ */ new Map();
+    this.terminalOutcomes = /* @__PURE__ */ new Map();
     this.coordinator = options.coordinator;
     this.createSessionImpl = options.createSession ?? createSession;
-    this.closeSessionAfterRefund = closeSessionAfterRefund;
+    this.closeSessionAfterOperationFailure = closeSessionAfterRefund;
   }
   onStateChange(listener) {
     this.stateListeners.add(listener);
@@ -268,6 +286,10 @@ var UserCoordinatorSession = class {
     this.coordinatorErrorListeners.add(listener);
     return () => this.coordinatorErrorListeners.delete(listener);
   }
+  onStorageError(listener) {
+    this.storageErrorListeners.add(listener);
+    return () => this.storageErrorListeners.delete(listener);
+  }
   get currentSwapState() {
     return this.swapState;
   }
@@ -278,51 +300,301 @@ var UserCoordinatorSession = class {
   get currentSwapId() {
     return this.swapId;
   }
+  clientPersistenceState() {
+    return this.session ? getSessionState(this.session).clientPersistence : disabledClientPersistence();
+  }
+  beginOperation() {
+    this.activeOperations += 1;
+    if (this.activeOperations === 1) this.setSessionStatus("connecting");
+  }
+  endOperation() {
+    this.activeOperations = Math.max(0, this.activeOperations - 1);
+    if (this.activeOperations === 0 && this.sessionStatus === "connecting") {
+      this.setSessionStatus("idle");
+    }
+  }
+  ensureSwapContext(swapId, syncSecret, resumeSecret) {
+    let context = this.swapContexts.get(swapId);
+    if (!context) {
+      context = {
+        swapId,
+        requestedAmountLamports: null,
+        swapState: this.swapId === swapId ? this.swapState : "new",
+        syncSecret: this.swapId === swapId && this.syncSecret ? new Uint8Array(this.syncSecret) : null,
+        resumeSecret: this.swapId === swapId && this.resumeSecret ? new Uint8Array(this.resumeSecret) : null,
+        bufferDepositConfirmedUntilDelegateAck: false,
+        bufferedDepositConfirmed: null
+      };
+      this.swapContexts.set(swapId, context);
+    }
+    if (syncSecret !== void 0) context.syncSecret = new Uint8Array(syncSecret);
+    if (resumeSecret !== void 0) context.resumeSecret = new Uint8Array(resumeSecret);
+    this.setCurrentContext(context);
+    return context;
+  }
+  setCurrentContext(context) {
+    this.swapId = context.swapId;
+    this.swapState = context.swapState;
+    this.syncSecret = context.syncSecret ? new Uint8Array(context.syncSecret) : null;
+    this.resumeSecret = context.resumeSecret ? new Uint8Array(context.resumeSecret) : null;
+  }
+  updateContextState(context, state) {
+    context.swapState = state;
+    if (this.swapId === context.swapId) {
+      this.swapState = state;
+    }
+    if (TERMINAL_SWAP_STATES.has(state)) {
+      this.evictSwapContext(context.swapId);
+    }
+    this.emitStateChange(context.swapId, state);
+  }
+  evictSwapContext(swapId) {
+    this.statusReconciliationStops.get(swapId)?.();
+    this.statusReconciliationStops.delete(swapId);
+    const context = this.swapContexts.get(swapId);
+    if (context) {
+      if (isTerminalSwapState(context.swapState)) {
+        this.rememberTerminalOutcome(swapId, context.swapState);
+      }
+      context.syncSecret?.fill(0);
+      context.resumeSecret?.fill(0);
+      context.bufferedDepositConfirmed = null;
+      context.bufferDepositConfirmedUntilDelegateAck = false;
+      this.swapContexts.delete(swapId);
+    }
+    if (this.swapId === swapId) {
+      this.syncSecret?.fill(0);
+      this.resumeSecret?.fill(0);
+      this.syncSecret = null;
+      this.resumeSecret = null;
+    }
+  }
+  clearSwapContexts() {
+    for (const swapId of this.swapContexts.keys()) this.evictSwapContext(swapId);
+    this.swapContexts.clear();
+    this.pushProcessing.clear();
+    this.terminalOutcomes.clear();
+    this.emittedPayoutKeys.clear();
+    this.emittedRefundKeys.clear();
+  }
+  isActiveSwapContext(context) {
+    return this.swapContexts.get(context.swapId) === context;
+  }
+  rememberTerminalOutcome(swapId, state, refund, storageError) {
+    const previous = this.terminalOutcomes.get(swapId);
+    this.terminalOutcomes.set(swapId, {
+      state,
+      ...refund !== void 0 && refund !== null ? { refund } : previous?.refund !== void 0 ? { refund: previous.refund } : {},
+      ...storageError !== void 0 ? { storageError } : previous?.storageError !== void 0 ? { storageError: previous.storageError } : {}
+    });
+    if (this.terminalOutcomes.size > MAX_EVENT_DEDUP_ENTRIES_PER_KIND) {
+      const oldest = this.terminalOutcomes.keys().next().value;
+      if (oldest !== void 0) this.terminalOutcomes.delete(oldest);
+    }
+  }
   async runSwap(params) {
     assertCurrentUserPayoutSpecRuntimeLimits(params.payoutSpec);
-    this.assertNoActiveContract();
-    this.setSessionStatus("connecting");
+    this.beginOperation();
     let completed = false;
+    let terminalStatus = null;
     try {
       await ensureFrostWasm();
       await this.openSession();
       this.setSessionStatus("running");
       const result = await this.runProtocol(params);
       completed = true;
-      this.setSessionStatus("done");
+      terminalStatus = "done";
       return result;
     } catch (err) {
       const error = this.normalizeSessionError(err);
       if (!isBenignTransportDrop(error)) {
-        this.setSessionStatus("failed");
+        terminalStatus = "failed";
       }
       throw error;
     } finally {
-      if (!completed) {
+      this.endOperation();
+      if (this.activeOperations === 0 && terminalStatus !== null) {
+        this.setSessionStatus(terminalStatus);
+      }
+      if (!completed && this.activeOperations === 0 && this.closeSessionAfterOperationFailure) {
         this.close();
       }
     }
   }
   async contractRequest(params) {
     assertCurrentUserPayoutSpecRuntimeLimits(params.payoutSpec);
-    this.assertNoActiveContract();
-    this.setSessionStatus("connecting");
+    this.beginOperation();
+    let completed = false;
+    let terminalStatus = null;
     try {
       await ensureFrostWasm();
       await this.openSession();
       this.setSessionStatus("running");
       const prepared = await this.prepareContract(params);
+      completed = true;
+      terminalStatus = "done";
       return toContractRequestResult(prepared);
     } catch (err) {
       const error = this.normalizeSessionError(err);
-      this.setSessionStatus("failed");
+      terminalStatus = "failed";
       throw error;
+    } finally {
+      this.endOperation();
+      if (this.activeOperations === 0 && terminalStatus !== null) {
+        this.setSessionStatus(terminalStatus);
+      }
+      if (!completed && this.activeOperations === 0 && this.closeSessionAfterOperationFailure) {
+        this.close();
+      }
+    }
+  }
+  async resumePreDelegation(params) {
+    if (!params.policySnapshot) {
+      throw new CommandError(
+        "REJECTED_GUARD",
+        "policySnapshot is required to resume pre-delegation"
+      );
+    }
+    if (params.recoveryCommitment.length !== SYNC_SECRET_BYTE_LENGTH) {
+      throw new CommandError(
+        "REJECTED_GUARD",
+        `recoveryCommitment must be ${SYNC_SECRET_BYTE_LENGTH} bytes`
+      );
+    }
+    this.beginOperation();
+    let completed = false;
+    let terminalStatus = null;
+    try {
+      await ensureFrostWasm();
+      this.restoreSwapContext({
+        swapId: params.swapId,
+        syncSecret: params.syncSecret,
+        resumeSecret: params.resumeSecret
+      });
+      await this.openSession();
+      this.setSessionStatus("running");
+      const context = this.ensureSwapContext(params.swapId);
+      context.swapState = params.delegateShare ? "awaiting_deposit" : "awaiting_dkg";
+      context.bufferDepositConfirmedUntilDelegateAck = true;
+      this.setCurrentContext(context);
+      let jointPublicKey;
+      let depositAddress;
+      let depositExpiresAtMs;
+      let coordinatorTimestampMs;
+      let delegateShare = params.delegateShare ? new Uint8Array(params.delegateShare) : void 0;
+      const persistence = this.clientPersistenceState();
+      const persistedResumeRecord = await readPersistedTransferForResume(
+        persistence,
+        context.swapId
+      );
+      if (params.delegateShare !== void 0 && persistedResumeRecord !== null) {
+        if (persistedResumeRecord.depositAddress === void 0 || persistedResumeRecord.depositExpiresAtMs === void 0 || persistedResumeRecord.coordinatorTimestampMs === void 0) {
+          throw new StorageError(
+            "STORAGE_KEY_MISSING",
+            "persisted DKG metadata is missing for saved delegate share",
+            { phase: "ready", swapId: context.swapId, remoteAccepted: false }
+          );
+        }
+        depositAddress = persistedResumeRecord.depositAddress;
+        depositExpiresAtMs = persistedResumeRecord.depositExpiresAtMs;
+        coordinatorTimestampMs = persistedResumeRecord.coordinatorTimestampMs;
+      }
+      if (!delegateShare) {
+        const dkg = await this.runDkg(
+          context,
+          params.onDelegateShareReady,
+          persistedResumeRecord !== null
+        );
+        jointPublicKey = dkg.jointPublicKey;
+        depositAddress = solanaAddressFromPublicKeyBytes(jointPublicKey);
+        depositExpiresAtMs = dkg.depositExpiresAtMs;
+        coordinatorTimestampMs = dkg.coordinatorTimestampMs;
+        delegateShare = dkg.keyHandle.secretShareBytes();
+        this.updateContextState(context, "awaiting_deposit");
+      }
+      const delegateAckPromise = this.awaitPush(CoordinatorMessageType.DelegateAck, context.swapId);
+      let delegateResp;
+      try {
+        delegateResp = await this.request(
+          CoordinatorMessageType.DelegateShare,
+          {
+            share: delegateShare,
+            recovery_commitment: new Uint8Array(params.recoveryCommitment),
+            resume_secret: context.resumeSecret
+          },
+          { swapId: context.swapId }
+        );
+      } catch (err) {
+        void delegateAckPromise.catch(() => void 0);
+        throw err;
+      }
+      const delegatedAtMs = this.requireProtocol().asDelegateShareResponsePayload(delegateResp).delegated_at_ms;
+      const delegateAck = this.requireProtocol().asDelegateAckPayload(await delegateAckPromise);
+      if (delegateAck.delegated_at_ms !== delegatedAtMs) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          "DelegateAck delegated_at_ms does not match DelegateShare response"
+        );
+      }
+      if (!spendingPoliciesEqual(delegateAck.spending_policy, params.policySnapshot)) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          "DelegateAck spending_policy does not match persisted policy_snapshot"
+        );
+      }
+      context.requestedAmountLamports = delegateAck.spending_policy.entry_amount_lamports;
+      if (context.bufferedDepositConfirmed) {
+        assertDepositConfirmedAmount(
+          this.requireProtocol(),
+          context.bufferedDepositConfirmed,
+          delegateAck.spending_policy.entry_amount_lamports
+        );
+      }
+      if (persistedResumeRecord !== null) {
+        if (depositAddress === void 0 || depositExpiresAtMs === void 0 || coordinatorTimestampMs === void 0) {
+          throw new StorageError(
+            "STORAGE_KEY_MISSING",
+            "persisted DKG metadata is missing for saved delegate share",
+            { phase: "ready", swapId: context.swapId, remoteAccepted: true }
+          );
+        }
+        await persistTransferReady(persistence, {
+          swapId: context.swapId,
+          depositAddress,
+          depositExpiresAtMs,
+          delegatedAtMs,
+          coordinatorTimestampMs
+        });
+      }
+      const hadBufferedDeposit = context.bufferedDepositConfirmed !== null;
+      await this.releaseDepositConfirmedGate(context);
+      if (!hadBufferedDeposit && this.isActiveSwapContext(context)) {
+        this.updateContextState(context, "awaiting_deposit");
+      }
+      completed = true;
+      terminalStatus = "done";
+      return {
+        swapId: context.swapId,
+        jointPublicKey,
+        depositExpiresAtMs,
+        coordinatorTimestampMs,
+        delegatedAtMs
+      };
+    } catch (err) {
+      terminalStatus = "failed";
+      throw this.normalizeSessionError(err);
+    } finally {
+      if (!completed) this.cancelPushWaitersForSwap(params.swapId);
+      this.endOperation();
+      if (this.activeOperations === 0 && terminalStatus !== null) {
+        this.setSessionStatus(terminalStatus);
+      }
     }
   }
   /** @internal Used by the functional Session API without closing its caller-owned session. */
   releaseWithoutClosing() {
-    this.stopStatusReconciliation?.();
-    this.stopStatusReconciliation = null;
+    this.stopAllStatusReconciliations();
+    this.clearSwapContexts();
     this.detachSession(
       new TransportError("CONNECTION_LOST", "coordinator session operation released"),
       false,
@@ -330,12 +602,16 @@ var UserCoordinatorSession = class {
     );
   }
   close() {
-    this.stopStatusReconciliation?.();
-    this.stopStatusReconciliation = null;
+    this.stopAllStatusReconciliations();
+    this.clearSwapContexts();
     this.detachSession(new TransportError("CONNECTION_LOST", "coordinator session closed"), true);
   }
+  stopAllStatusReconciliations() {
+    for (const stop of [...this.statusReconciliationStops.values()]) stop();
+    this.statusReconciliationStops.clear();
+  }
   restoreSwapContext(params) {
-    this.swapId = params.swapId;
+    if (this.terminalOutcomes.has(params.swapId)) return;
     if (params.syncSecret !== void 0) {
       if (params.syncSecret.length !== SYNC_SECRET_BYTE_LENGTH) {
         throw new CommandError(
@@ -343,28 +619,52 @@ var UserCoordinatorSession = class {
           `syncSecret must be ${SYNC_SECRET_BYTE_LENGTH} bytes`
         );
       }
-      this.syncSecret = new Uint8Array(params.syncSecret);
     }
+    if (params.resumeSecret !== void 0) {
+      if (params.resumeSecret.length !== RESUME_SECRET_BYTE_LENGTH) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          `resumeSecret must be ${RESUME_SECRET_BYTE_LENGTH} bytes`
+        );
+      }
+    }
+    this.ensureSwapContext(params.swapId, params.syncSecret, params.resumeSecret);
   }
   async requestSwapStatus(timeoutMs) {
     if (!this.swapId) {
       throw new CommandError("REJECTED_STATE", "Sync requires swapId");
     }
+    const context = this.ensureSwapContext(this.swapId, this.syncSecret ?? void 0);
+    return this.requestSwapStatusForContext(context, timeoutMs);
+  }
+  async requestSwapStatusForContext(context, timeoutMs) {
     await this.openSession();
     const env = await this.request(
       CoordinatorMessageType.Sync,
       {
         actor: "user",
-        ...this.syncSecret ? { sync_secret: this.syncSecret } : {}
+        ...context.syncSecret ? { sync_secret: context.syncSecret } : {}
       },
-      timeoutMs
+      {
+        swapId: context.swapId,
+        timeoutMs,
+        rejectMatchingOutOfBandErrors: true
+      }
     );
     const status = this.requireProtocol().asSyncUserResponsePayload(env);
-    this.applySwapStatus(status, env.timestamp_ms);
+    const persistence = this.clientPersistenceState();
+    await this.enqueueSwapProcessing(context.swapId, async () => {
+      if (!this.isActiveSwapContext(context)) return;
+      await persistTransferStatus(persistence, context.swapId, status, env.timestamp_ms);
+      if (!this.isActiveSwapContext(context)) return;
+      this.applySwapStatus(context, status, env.timestamp_ms);
+    });
     return status;
   }
   startSwapStatusReconciliation(intervalMs = DEFAULT_SWAP_STATUS_RECONCILE_INTERVAL_MS) {
-    this.stopStatusReconciliation?.();
+    const reconciliationContext = this.swapId ? this.ensureSwapContext(this.swapId, this.syncSecret ?? void 0) : null;
+    const reconciliationKey = reconciliationContext?.swapId ?? UNBOUND_RECONCILIATION_KEY;
+    this.statusReconciliationStops.get(reconciliationKey)?.();
     let stopped = false;
     let reconciling = false;
     let timer = null;
@@ -389,20 +689,18 @@ var UserCoordinatorSession = class {
       if (stopped || reconciling || !isVisible()) return;
       reconciling = true;
       try {
-        const status = await this.requestSwapStatus();
+        const status = reconciliationContext ? await this.requestSwapStatusForContext(reconciliationContext) : await this.requestSwapStatus();
         retryBackoff.reset();
         if (status.state === "completed" || status.state === "refunded" || status.state === "failed") {
-          stopped = true;
-          if (timer) clearTimeout(timer);
+          stopReconciliation();
         } else {
           schedule(intervalMs);
         }
       } catch (err) {
         this.log(`SwapStatus reconcile failed: ${normalizeError(err)}`, "info");
         if (!isRetryableSwapStatusReconciliationError(err)) {
-          stopped = true;
-          if (timer) clearTimeout(timer);
-          this.close();
+          stopReconciliation();
+          if (err instanceof AttestationError) this.close();
           return;
         }
         schedule(retryBackoff.nextDelayMs());
@@ -438,7 +736,8 @@ var UserCoordinatorSession = class {
     browserDocument?.addEventListener("freeze", handleFreeze);
     browserDocument?.addEventListener("resume", reconcileWhenVisible);
     reconcileWhenVisible();
-    this.stopStatusReconciliation = () => {
+    const stopReconciliation = () => {
+      if (stopped) return;
       stopped = true;
       if (timer) clearTimeout(timer);
       browserWindow?.removeEventListener("focus", reconcileWhenVisible);
@@ -447,8 +746,12 @@ var UserCoordinatorSession = class {
       browserDocument?.removeEventListener("visibilitychange", handleVisibilityChange);
       browserDocument?.removeEventListener("freeze", handleFreeze);
       browserDocument?.removeEventListener("resume", reconcileWhenVisible);
+      if (this.statusReconciliationStops.get(reconciliationKey) === stopReconciliation) {
+        this.statusReconciliationStops.delete(reconciliationKey);
+      }
     };
-    return this.stopStatusReconciliation;
+    this.statusReconciliationStops.set(reconciliationKey, stopReconciliation);
+    return stopReconciliation;
   }
   async requestRefund(params) {
     const result = await this.requestRefundIntentInternal(params, { waitForFinality: true });
@@ -460,9 +763,10 @@ var UserCoordinatorSession = class {
   }
   async requestRefundIntentInternal(params, options) {
     assertRecoveryCode(params.recoveryCode);
+    this.beginOperation();
     const recoveryCode = new Uint8Array(params.recoveryCode);
     const ackTimeout = params.timeoutMs ?? 3e4;
-    let ackTimer;
+    let requestSwapId = params.swapId ?? null;
     let openedForRefund = false;
     try {
       if (params.syncSecret !== void 0) {
@@ -471,34 +775,51 @@ var UserCoordinatorSession = class {
           throw new CommandError("REJECTED_STATE", "syncSecret requires swapId");
         }
         this.restoreSwapContext({ swapId, syncSecret: params.syncSecret });
+        this.ensureRefundContext(swapId);
+        requestSwapId = swapId;
       } else if (params.swapId) {
         const swapId = params.swapId;
         this.restoreSwapContext({ swapId });
+        this.ensureRefundContext(swapId);
+        requestSwapId = swapId;
       }
       openedForRefund = !this.hasUsableSession();
       await this.openSession();
-      const env = await Promise.race([
-        this.request(CoordinatorMessageType.WithdrawRequest, {
-          recovery_code: recoveryCode
-        }),
-        new Promise((_, reject) => {
-          ackTimer = setTimeout(
-            () => reject(
-              new CommandError(
-                "REJECTED_STALE_JOB",
-                `WithdrawRequest acknowledgement timed out after ${ackTimeout}ms`
-              )
-            ),
-            ackTimeout
+      let env;
+      try {
+        env = await this.request(
+          CoordinatorMessageType.WithdrawRequest,
+          {
+            recovery_code: recoveryCode
+          },
+          { swapId: requestSwapId, timeoutMs: ackTimeout }
+        );
+      } catch (err) {
+        if (isRequestTimeoutError(err)) {
+          throw new CommandError(
+            "REJECTED_STALE_JOB",
+            `WithdrawRequest acknowledgement timed out after ${ackTimeout}ms`
           );
-        })
-      ]);
-      if (ackTimer) clearTimeout(ackTimer);
+        }
+        throw err;
+      }
       if (env.type === CoordinatorMessageType.WithdrawExecuted) {
-        if (env.swap_id && !this.swapId) {
-          this.swapId = env.swap_id;
+        const resolvedSwapId2 = env.swap_id ?? requestSwapId;
+        if (resolvedSwapId2) requestSwapId = resolvedSwapId2;
+        if (resolvedSwapId2) await this.waitForPushProcessing(resolvedSwapId2);
+        const terminalOutcome2 = resolvedSwapId2 ? this.terminalOutcomes.get(resolvedSwapId2) : void 0;
+        if (terminalOutcome2?.storageError) throw terminalOutcome2.storageError;
+        if (!terminalOutcome2) this.ensureRefundContext(resolvedSwapId2);
+        const refund = this.requireProtocol().asWithdrawExecutedPayload(env);
+        if (resolvedSwapId2 && terminalOutcome2?.refund === void 0) {
+          await persistTransferTerminal(
+            this.clientPersistenceState(),
+            resolvedSwapId2,
+            "refunded",
+            env.timestamp_ms
+          );
         }
-        return { kind: "executed", refund: this.requireProtocol().asWithdrawExecutedPayload(env) };
+        return { kind: "executed", refund };
       }
       if (env.type !== CoordinatorMessageType.WithdrawAccepted) {
         throw new CommandError(
@@ -506,29 +827,61 @@ var UserCoordinatorSession = class {
           `Expected WithdrawAccepted or WithdrawExecuted response, got ${env.type}`
         );
       }
-      if (env.swap_id && !this.swapId) {
-        this.swapId = env.swap_id;
-      }
       const accepted = this.requireProtocol().asWithdrawAcceptedPayload(env);
+      const resolvedSwapId = env.swap_id ?? requestSwapId;
+      if (resolvedSwapId) requestSwapId = resolvedSwapId;
+      if (resolvedSwapId) await this.waitForPushProcessing(resolvedSwapId);
+      let terminalOutcome = resolvedSwapId ? this.terminalOutcomes.get(resolvedSwapId) : void 0;
+      if (terminalOutcome?.storageError) throw terminalOutcome.storageError;
+      let resolvedContext = terminalOutcome ? null : this.ensureRefundContext(resolvedSwapId);
+      if (resolvedSwapId && !terminalOutcome) {
+        await persistTransferRecoveryCode(
+          this.clientPersistenceState(),
+          resolvedSwapId,
+          recoveryCode
+        );
+        await this.waitForPushProcessing(resolvedSwapId);
+        terminalOutcome = this.terminalOutcomes.get(resolvedSwapId);
+        if (terminalOutcome?.storageError) throw terminalOutcome.storageError;
+        if (terminalOutcome) resolvedContext = null;
+      }
       if (!options.waitForFinality) {
         return { kind: "accepted", accepted };
       }
-      if (!this.swapId) {
-        throw new CommandError(
-          "REJECTED_STALE_JOB",
-          "refund accepted and pending finalization; check status again shortly"
-        );
+      if (terminalOutcome?.refund !== void 0) {
+        return { kind: "executed", refund: terminalOutcome.refund };
       }
-      return { kind: "executed", refund: await this.awaitRefundOutcomeFromSwapStatus() };
+      if (!resolvedContext) {
+        throw new CommandError("REJECTED_STALE_JOB", REFUND_PENDING_FINALIZATION_MESSAGE);
+      }
+      if (!resolvedContext.syncSecret) {
+        throw new CommandError("REJECTED_STALE_JOB", REFUND_PENDING_FINALIZATION_MESSAGE);
+      }
+      this.setCurrentContext(resolvedContext);
+      return {
+        kind: "executed",
+        refund: await this.awaitRefundOutcomeFromSwapStatus(resolvedContext)
+      };
     } finally {
-      if (ackTimer) clearTimeout(ackTimer);
       recoveryCode.fill(0);
-      if (openedForRefund && this.closeSessionAfterRefund) {
+      this.endOperation();
+      if (openedForRefund && this.closeSessionAfterOperationFailure && this.activeOperations === 0) {
+        await this.waitForPushProcessing(requestSwapId);
         this.close();
       }
     }
   }
-  async awaitRefundOutcomeFromSwapStatus() {
+  ensureRefundContext(swapId) {
+    if (swapId === null) return null;
+    if (this.terminalOutcomes.has(swapId)) return null;
+    const context = this.ensureSwapContext(swapId);
+    if (context.swapState === "new") {
+      context.swapState = "awaiting_deposit";
+      this.setCurrentContext(context);
+    }
+    return context;
+  }
+  async awaitRefundOutcomeFromSwapStatus(context) {
     const deadline = Date.now() + DEFAULT_REFUND_OUTCOME_POLL_BUDGET_MS;
     for (; ; ) {
       const perPollTimeout = Math.min(
@@ -536,7 +889,7 @@ var UserCoordinatorSession = class {
         Math.max(0, deadline - Date.now())
       );
       try {
-        const status = await this.requestSwapStatus(perPollTimeout);
+        const status = await this.requestSwapStatusForContext(context, perPollTimeout);
         if (status.withdraw_execution) {
           return status.withdraw_execution;
         }
@@ -546,10 +899,7 @@ var UserCoordinatorSession = class {
         }
       }
       if (Date.now() >= deadline) {
-        throw new CommandError(
-          "REJECTED_STALE_JOB",
-          "refund accepted and pending finalization; check status again shortly"
-        );
+        throw new CommandError("REJECTED_STALE_JOB", REFUND_PENDING_FINALIZATION_MESSAGE);
       }
       await delay(REFUND_OUTCOME_POLL_INTERVAL_MS);
     }
@@ -558,25 +908,29 @@ var UserCoordinatorSession = class {
     const protocol = this.requireProtocol();
     const prepared = await this.prepareContract(params);
     const depositEnv = await prepared.depositConfirmedPromise;
-    const depositPayload = protocol.asDepositConfirmedPayload(depositEnv);
-    if (depositPayload.amount_lamports !== params.amountLamports) {
-      throw new InvalidDepositAmountError(
-        BigInt(depositPayload.amount_lamports),
-        BigInt(params.amountLamports)
-      );
-    }
+    const depositPayload = assertDepositConfirmedAmount(
+      protocol,
+      depositEnv,
+      params.amountLamports
+    );
     this.log(
       `deposit confirmed tx=${depositPayload.tx_signature} amount=${depositPayload.amount_lamports}`,
       "in"
     );
     await params.onDepositConfirmed?.({ originAddress: depositPayload.origin_address });
-    await this.requestSwapStatus();
+    const context = this.swapContexts.get(prepared.swapId);
+    if (!context) {
+      throw new CommandError("REJECTED_STATE", `missing client context for ${prepared.swapId}`);
+    }
+    await this.requestSwapStatusForContext(context);
     return {
       swapId: prepared.swapId,
       jointPublicKey: prepared.jointPublicKey,
       depositTxSignature: depositPayload.tx_signature,
       depositObservedAtMs: depositPayload.observed_at_ms,
       delegatedAtMs: prepared.delegatedAtMs,
+      resumeSecret: new Uint8Array(prepared.resumeSecret),
+      resumeSecretHex: prepared.resumeSecretHex,
       recoveryCodeHex: prepared.recoveryCodeHex,
       policySnapshot: prepared.policySnapshot,
       delegatePolicySnapshot: prepared.delegatePolicySnapshot
@@ -587,6 +941,7 @@ var UserCoordinatorSession = class {
     const requestedPayoutWindowMs = params.payoutWindowMs ?? payoutWindowMsFromSpec(params.payoutSpec);
     const payoutDeadlineMs = requestedPayoutWindowMs !== void 0 ? Date.now() + requestedPayoutWindowMs : void 0;
     let generatedSyncSecret = null;
+    let generatedResumeSecret = null;
     const syncSecret = params.syncSecret ? new Uint8Array(params.syncSecret) : (() => {
       generatedSyncSecret = randomSecret32();
       return generatedSyncSecret;
@@ -597,105 +952,193 @@ var UserCoordinatorSession = class {
         `syncSecret must be ${SYNC_SECRET_BYTE_LENGTH} bytes`
       );
     }
-    this.syncSecret = new Uint8Array(syncSecret);
     const syncSecretHex = bytesToHex(syncSecret);
     const syncCommitment = await sha256Commitment(syncSecret);
     if (generatedSyncSecret) {
       await params.onSyncSecretReady?.({ secretHex: syncSecretHex });
     }
-    const swapResp = await this.request(CoordinatorMessageType.ContractRequest, {
-      actor: "user",
-      amount_lamports: params.amountLamports,
-      payout_spec: params.payoutSpec,
-      sync_commitment: syncCommitment,
-      ...(params.payoutDeadlineMs !== void 0 || payoutDeadlineMs !== void 0) && {
-        payout_deadline_ms: params.payoutDeadlineMs ?? payoutDeadlineMs
-      }
-    });
-    const swapPayload = protocol.asSwapRequestResponsePayload(swapResp);
-    const swapId = swapPayload.swap_id;
-    this.swapId = swapId;
-    params.onPolicySnapshot?.(swapPayload.policy_snapshot);
-    this.log(`swap accepted - id=${swapId}`, "in");
-    this.bufferDepositConfirmedUntilDelegateAck = true;
-    this.bufferedDepositConfirmed = null;
-    const depositConfirmedPromise = this.awaitPush(CoordinatorMessageType.DepositConfirmed, null);
-    void depositConfirmedPromise.catch(() => void 0);
-    const { jointPublicKey, keyHandle, depositExpiresAtMs, coordinatorTimestampMs } = await this.runDkg();
-    let recoveryCommitment = params.recoveryCommitment;
-    let recoveryCodeHex;
-    if (!recoveryCommitment) {
-      const generated = await generateRecoveryCode();
-      recoveryCommitment = generated.commitment;
-      try {
-        recoveryCodeHex = recoveryCodeToHex(generated.code);
-        await params.onRecoveryCodeReady?.({ codeHex: recoveryCodeHex });
-      } finally {
-        generated.code.fill(0);
-      }
-    }
-    const delegateAckPromise = this.awaitPush(CoordinatorMessageType.DelegateAck);
-    const share = params.delegateShare ?? keyHandle.secretShareBytes();
-    let delegateResp;
-    try {
-      delegateResp = await this.request(CoordinatorMessageType.DelegateShare, {
-        share,
-        recovery_commitment: recoveryCommitment
-      });
-    } catch (err) {
-      void delegateAckPromise.catch(() => void 0);
-      throw err;
-    }
-    const delegatePayload = protocol.asDelegateShareResponsePayload(delegateResp);
-    const delegateAck = protocol.asDelegateAckPayload(await delegateAckPromise);
-    if (delegateAck.delegated_at_ms !== delegatePayload.delegated_at_ms) {
+    const resumeSecret = params.resumeSecret ? new Uint8Array(params.resumeSecret) : (() => {
+      generatedResumeSecret = randomSecret32();
+      return generatedResumeSecret;
+    })();
+    if (resumeSecret.length !== RESUME_SECRET_BYTE_LENGTH) {
       throw new CommandError(
         "REJECTED_GUARD",
-        "DelegateAck delegated_at_ms does not match DelegateShare response"
+        `resumeSecret must be ${RESUME_SECRET_BYTE_LENGTH} bytes`
       );
     }
-    if (!spendingPoliciesEqual(delegateAck.spending_policy, swapPayload.policy_snapshot)) {
-      throw new CommandError(
-        "REJECTED_GUARD",
-        "DelegateAck spending_policy does not match ContractRequest policy_snapshot"
-      );
+    const resumeSecretHex = bytesToHex(resumeSecret);
+    const resumeCommitment = await sha256Commitment(resumeSecret);
+    if (generatedResumeSecret) {
+      await params.onResumeSecretReady?.({ secretHex: resumeSecretHex });
     }
-    this.log(`delegated at ${delegateAck.delegated_at_ms}`, "in");
-    this.releaseDepositConfirmedGate();
-    await params.onDepositAddressReady?.({
+    const swapResp = await this.request(
+      CoordinatorMessageType.ContractRequest,
+      {
+        actor: "user",
+        amount_lamports: params.amountLamports,
+        payout_spec: params.payoutSpec,
+        sync_commitment: syncCommitment,
+        resume_commitment: resumeCommitment,
+        ...(params.payoutDeadlineMs !== void 0 || payoutDeadlineMs !== void 0) && {
+          payout_deadline_ms: params.payoutDeadlineMs ?? payoutDeadlineMs
+        }
+      },
+      { swapId: null, requireNonNullResponseSwapId: true }
+    );
+    const swapPayload = protocol.asSwapRequestResponsePayload(swapResp);
+    const swapId = swapPayload.swap_id;
+    const context = {
       swapId,
-      jointPublicKey,
-      amountLamports: params.amountLamports,
-      depositExpiresAtMs,
-      coordinatorTimestampMs
-    });
-    return {
-      requestId: swapId,
+      requestedAmountLamports: params.amountLamports,
+      swapState: "awaiting_dkg",
+      syncSecret: new Uint8Array(syncSecret),
+      resumeSecret: new Uint8Array(resumeSecret),
+      bufferDepositConfirmedUntilDelegateAck: true,
+      bufferedDepositConfirmed: null
+    };
+    this.swapContexts.set(swapId, context);
+    this.setCurrentContext(context);
+    await persistTransferAllocation(this.clientPersistenceState(), {
       swapId,
       amountLamports: params.amountLamports,
-      jointPublicKey,
-      depositExpiresAtMs,
-      coordinatorTimestampMs,
-      delegatedAtMs: delegateAck.delegated_at_ms,
+      payoutSpec: params.payoutSpec,
+      policySnapshot: swapPayload.policy_snapshot,
       syncSecret,
+      coordinatorTimestampMs: swapResp.timestamp_ms
+    });
+    await params.onSwapAllocated?.({
+      swapId,
       syncSecretHex,
-      recoveryCodeHex,
-      policySnapshot: swapPayload.policy_snapshot,
-      delegatePolicySnapshot: delegateAck.spending_policy,
-      depositConfirmedPromise
-    };
+      resumeSecretHex
+    });
+    params.onPolicySnapshot?.(swapPayload.policy_snapshot);
+    this.log(`swap accepted - id=${swapId}`, "in");
+    let preparedSuccessfully = false;
+    try {
+      const depositConfirmedPromise = this.awaitPush(
+        CoordinatorMessageType.DepositConfirmed,
+        context.swapId,
+        null
+      );
+      void depositConfirmedPromise.catch(() => void 0);
+      const { jointPublicKey, keyHandle, depositExpiresAtMs, coordinatorTimestampMs } = await this.runDkg(context, params.delegateShare ? void 0 : params.onDelegateShareReady);
+      this.updateContextState(context, "awaiting_deposit");
+      let recoveryCommitment = params.recoveryCommitment;
+      let recoveryCodeHex;
+      if (!recoveryCommitment) {
+        const generated = await generateRecoveryCode();
+        recoveryCommitment = generated.commitment;
+        try {
+          recoveryCodeHex = recoveryCodeToHex(generated.code);
+          await persistTransferRecoveryCode(
+            this.clientPersistenceState(),
+            context.swapId,
+            generated.code
+          );
+          await params.onRecoveryCodeReady?.({ codeHex: recoveryCodeHex });
+        } finally {
+          generated.code.fill(0);
+        }
+      }
+      const delegateAckPromise = this.awaitPush(CoordinatorMessageType.DelegateAck, context.swapId);
+      const share = params.delegateShare ?? keyHandle.secretShareBytes();
+      let delegateResp;
+      try {
+        delegateResp = await this.request(
+          CoordinatorMessageType.DelegateShare,
+          {
+            share,
+            recovery_commitment: recoveryCommitment,
+            resume_secret: context.resumeSecret
+          },
+          { swapId: context.swapId }
+        );
+      } catch (err) {
+        void delegateAckPromise.catch(() => void 0);
+        throw err;
+      }
+      const delegatePayload = protocol.asDelegateShareResponsePayload(delegateResp);
+      const delegateAck = protocol.asDelegateAckPayload(await delegateAckPromise);
+      if (delegateAck.delegated_at_ms !== delegatePayload.delegated_at_ms) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          "DelegateAck delegated_at_ms does not match DelegateShare response"
+        );
+      }
+      if (!spendingPoliciesEqual(delegateAck.spending_policy, swapPayload.policy_snapshot)) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          "DelegateAck spending_policy does not match ContractRequest policy_snapshot"
+        );
+      }
+      if (context.bufferedDepositConfirmed) {
+        assertDepositConfirmedAmount(
+          this.requireProtocol(),
+          context.bufferedDepositConfirmed,
+          params.amountLamports
+        );
+      }
+      await persistTransferReady(this.clientPersistenceState(), {
+        swapId,
+        depositAddress: solanaAddressFromPublicKeyBytes(jointPublicKey),
+        depositExpiresAtMs,
+        delegatedAtMs: delegateAck.delegated_at_ms,
+        coordinatorTimestampMs
+      });
+      this.log(`delegated at ${delegateAck.delegated_at_ms}`, "in");
+      await this.releaseDepositConfirmedGate(context);
+      await params.onDepositAddressReady?.({
+        swapId,
+        jointPublicKey,
+        amountLamports: params.amountLamports,
+        depositExpiresAtMs,
+        coordinatorTimestampMs
+      });
+      preparedSuccessfully = true;
+      return {
+        requestId: swapId,
+        swapId,
+        amountLamports: params.amountLamports,
+        jointPublicKey,
+        depositExpiresAtMs,
+        coordinatorTimestampMs,
+        delegatedAtMs: delegateAck.delegated_at_ms,
+        syncSecret,
+        syncSecretHex,
+        resumeSecret,
+        resumeSecretHex,
+        recoveryCodeHex,
+        policySnapshot: swapPayload.policy_snapshot,
+        delegatePolicySnapshot: delegateAck.spending_policy,
+        depositConfirmedPromise
+      };
+    } finally {
+      if (!preparedSuccessfully) {
+        this.cancelPushWaitersForSwap(context.swapId);
+      }
+    }
   }
-  async runDkg() {
+  async runDkg(context, onDelegateShareReady, persistDkgMetadata = true) {
     await ensureFrostWasm();
     const protocol = this.requireProtocol();
     const { dkgRound1 } = await loadFrost();
-    await this.request(CoordinatorMessageType.DkgInit, {});
+    await this.request(
+      CoordinatorMessageType.DkgInit,
+      { resume_secret: context.resumeSecret },
+      { swapId: context.swapId }
+    );
     this.log("DKG initialised", "info");
     const aliceRound1State = dkgRound1(ALICE_ID);
     const aliceRound1Bytes = aliceRound1State.round1PackageBytes();
-    const round1Resp = await this.request(CoordinatorMessageType.DkgRound1, {
-      package: aliceRound1Bytes
-    });
+    const round1Resp = await this.request(
+      CoordinatorMessageType.DkgRound1,
+      {
+        package: aliceRound1Bytes,
+        resume_secret: context.resumeSecret
+      },
+      { swapId: context.swapId }
+    );
     const round1Payload = protocol.asDkgRound1ResponsePayload(round1Resp);
     this.log(`DKG round1 complete - coord pkg ${round1Payload.package.byteLength}B`, "in");
     const aliceRound2State = aliceRound1State.intoRound2(COORDINATOR_ID, round1Payload.package);
@@ -710,10 +1153,20 @@ var UserCoordinatorSession = class {
     } catch (err) {
       throw new CommandError("REJECTED_GUARD", `Alice DKG finalize failed: ${normalizeError(err)}`);
     }
-    const dkgCompletePromise = this.awaitPush(CoordinatorMessageType.DkgComplete);
-    await this.request(CoordinatorMessageType.DkgRound2, {
-      package: aliceRound2Bytes
+    await onDelegateShareReady?.({
+      swapId: context.swapId,
+      delegateShare: new Uint8Array(aliceKeyHandle.secretShareBytes())
     });
+    const dkgCompletePromise = this.awaitPush(CoordinatorMessageType.DkgComplete, context.swapId);
+    void dkgCompletePromise.catch(() => void 0);
+    await this.request(
+      CoordinatorMessageType.DkgRound2,
+      {
+        package: aliceRound2Bytes,
+        resume_secret: context.resumeSecret
+      },
+      { swapId: context.swapId }
+    );
     const completeEnvelope = await dkgCompletePromise;
     const complete = readDkgComplete(protocol, completeEnvelope);
     const alicePubkey = aliceKeyHandle.groupPublicKeyBytes();
@@ -723,6 +1176,14 @@ var UserCoordinatorSession = class {
         "DKG joint public key mismatch between Alice and coordinator"
       );
     }
+    if (persistDkgMetadata) {
+      await persistTransferDkgMetadata(this.clientPersistenceState(), {
+        swapId: context.swapId,
+        depositAddress: solanaAddressFromPublicKeyBytes(alicePubkey),
+        depositExpiresAtMs: complete.depositExpiresAtMs,
+        coordinatorTimestampMs: complete.coordinatorTimestampMs
+      });
+    }
     const pubkeyHexPrefix = Array.from(alicePubkey.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("");
     this.log(`DKG complete - joint pubkey ${pubkeyHexPrefix}`, "info");
     return {
@@ -733,6 +1194,20 @@ var UserCoordinatorSession = class {
     };
   }
   async openSession() {
+    if (this.hasUsableSession()) return;
+    if (this.openingSession !== null) {
+      await this.openingSession;
+      return;
+    }
+    const opening = this.openSessionOnce();
+    this.openingSession = opening;
+    try {
+      await opening;
+    } finally {
+      if (this.openingSession === opening) this.openingSession = null;
+    }
+  }
+  async openSessionOnce() {
     if (this.hasUsableSession()) return;
     if (this.session !== null) {
       this.detachSession(
@@ -758,11 +1233,6 @@ var UserCoordinatorSession = class {
     this.log(`connected to ${this.coordinator.endpoints[0]?.wsUrl ?? "coordinator"}`, "info");
     this.log("attestation verified", "info");
   }
-  assertNoActiveContract() {
-    if (this.swapId !== null || this.sessionStatus === "connecting" || this.sessionStatus === "running") {
-      throw new CommandError("REJECTED_STATE", ACTIVE_CONTRACT_REQUEST_MESSAGE);
-    }
-  }
   hasUsableSession() {
     if (this.session === null) return false;
     const state = getSessionState(this.session);
@@ -788,61 +1258,213 @@ var UserCoordinatorSession = class {
   handleEnvelope(env) {
     const protocol = this.requireProtocol();
     this.log(`<- ${env.type} kind=${env.kind}`, "in");
-    const payoutExecuted = env.kind === EnvelopeKind.PUSH && env.type === CoordinatorMessageType.PayoutExecuted ? protocol.asPayoutExecutedPayload(env) : null;
-    const payoutMatchesCurrentSwap = payoutExecuted !== null && (env.swap_id === null || env.swap_id === this.swapId);
-    const refundExecuted = env.kind === EnvelopeKind.PUSH && env.type === CoordinatorMessageType.WithdrawExecuted ? protocol.asWithdrawExecutedPayload(env) : null;
+    if (env.kind === EnvelopeKind.PUSH) {
+      if (env.swap_id === null) {
+        this.log(`ignored ${env.type} without an explicit swap_id`, "info");
+        return;
+      }
+      if (!this.swapContexts.has(env.swap_id)) {
+        this.log(`ignored ${env.type} for unknown swap ${env.swap_id}`, "info");
+        return;
+      }
+      this.enqueuePush(env);
+      return;
+    }
+    const context = env.swap_id ? this.swapContexts.get(env.swap_id) ?? null : null;
+    if (env.swap_id === null && env.kind !== EnvelopeKind.ERROR) {
+      this.log(`ignored ${env.type} without an explicit swap_id`, "info");
+      return;
+    }
+    if (env.swap_id !== null && context === null) {
+      this.log(`ignored ${env.type} for unknown swap ${env.swap_id}`, "info");
+      return;
+    }
+    const stateForEnvelope = context?.swapState ?? this.swapState;
+    const next = protocol.nextState(stateForEnvelope, env.kind, env.type);
+    if (next !== null) {
+      if (context) {
+        this.updateContextState(context, next);
+      } else {
+        this.swapState = next;
+        this.emitStateChange(this.swapId, next);
+      }
+    }
+    if (env.kind === EnvelopeKind.ERROR) {
+      const coordinatorError = coordinatorErrorFromEnvelope(protocol, env);
+      if (env.req_id === 0) {
+        for (const listener of this.coordinatorErrorListeners) {
+          listener(coordinatorError);
+        }
+      }
+      return;
+    }
+  }
+  enqueuePush(env) {
+    const swapId = env.swap_id;
+    if (swapId === null) return;
+    const context = this.swapContexts.get(swapId);
+    if (context === void 0) return;
+    const persistence = this.clientPersistenceState();
+    void this.enqueueSwapProcessing(
+      swapId,
+      () => this.processPushEnvelope(env, context, persistence)
+    ).catch(() => void 0);
+  }
+  enqueueSwapProcessing(swapId, process) {
+    const previous = this.pushProcessing.get(swapId) ?? Promise.resolve();
+    const processing = previous.catch(() => void 0).then(process);
+    this.pushProcessing.set(swapId, processing);
+    void processing.finally(() => {
+      if (this.pushProcessing.get(swapId) === processing) {
+        this.pushProcessing.delete(swapId);
+      }
+    }).catch(() => void 0);
+    return processing;
+  }
+  async waitForPushProcessing(swapId) {
+    if (swapId === null) return;
+    await (this.pushProcessing.get(swapId)?.catch(() => void 0) ?? Promise.resolve());
+  }
+  async processPushEnvelope(env, context, persistence) {
+    const protocol = this.requireProtocol();
+    const payoutExecuted = env.type === CoordinatorMessageType.PayoutExecuted ? protocol.asPayoutExecutedPayload(env) : null;
+    const refundExecuted = env.type === CoordinatorMessageType.WithdrawExecuted ? protocol.asWithdrawExecutedPayload(env) : null;
     if (this.shouldBufferDepositConfirmed(env)) {
       this.bufferDepositConfirmed(env);
       return;
     }
-    const foreignPayout = payoutExecuted !== null && !payoutMatchesCurrentSwap;
-    const next = foreignPayout ? null : protocol.nextState(
-      this.swapState,
+    if (env.type === CoordinatorMessageType.DkgComplete) {
+      this.settlePushListener(env);
+      return;
+    }
+    if (env.type === CoordinatorMessageType.DepositConfirmed) {
+      if (context.requestedAmountLamports === null) {
+        this.log(
+          `ignored DepositConfirmed for swap ${context.swapId} without requested amount`,
+          "info"
+        );
+        return;
+      }
+      try {
+        assertDepositConfirmedAmount(protocol, env, context.requestedAmountLamports);
+      } catch (error) {
+        this.settlePushListener(env, error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+    }
+    const next = protocol.nextState(
+      context.swapState,
       env.kind,
       env.type,
       payoutExecuted ? { payoutFinal: payoutExecuted.final } : void 0
     );
-    if (env.kind === EnvelopeKind.PUSH && next === null) {
+    if (next === null) {
       this.log(
-        foreignPayout ? `ignored ${env.type} for swap ${env.swap_id ?? "null"} while current swap is ${this.swapId ?? "none"}` : `ignored invalid push ${env.type} in state ${this.swapState}`,
+        `ignored ${env.type} for swap ${env.swap_id ?? "null"} while client context is ${context.swapId} in state ${context.swapState}`,
         "info"
       );
       return;
     }
-    if (next !== null) {
-      this.swapState = next;
-      this.emitStateChange();
-    }
-    if (env.kind === EnvelopeKind.ERROR) {
-      const coordinatorError = coordinatorErrorFromEnvelope(protocol, env);
-      if (env.req_id === 0) {
-        for (const listener of this.coordinatorErrorListeners) {
-          listener(coordinatorError);
-        }
+    if (env.type === CoordinatorMessageType.DelegateAck) {
+      if (!this.isActiveSwapContext(context)) {
+        context.swapState = next;
+        return;
       }
+      this.updateContextState(context, next);
+      this.settlePushListener(env);
       return;
     }
-    if (env.kind === EnvelopeKind.PUSH) {
-      if (payoutExecuted && payoutMatchesCurrentSwap) {
-        this.emitPayoutExecuted(payoutExecuted, env.swap_id ?? this.swapId);
+    if (isTerminalSwapState(next)) {
+      await this.handleTerminalPush(
+        env,
+        context,
+        next,
+        payoutExecuted,
+        refundExecuted,
+        persistence
+      );
+      return;
+    }
+    await this.handleNonTerminalPush(env, context, next, payoutExecuted, persistence);
+  }
+  async handleNonTerminalPush(env, context, next, payoutExecuted, persistence) {
+    if (!this.isActiveSwapContext(context)) {
+      context.swapState = next;
+      return;
+    }
+    let storageError = null;
+    try {
+      await persistTransferStatus(persistence, context.swapId, { state: next }, env.timestamp_ms);
+    } catch (error) {
+      storageError = storageErrorFromPush(error, context.swapId, null);
+    }
+    if (!this.isActiveSwapContext(context)) {
+      context.swapState = next;
+      return;
+    }
+    try {
+      this.updateContextState(context, next);
+      if (payoutExecuted) this.emitPayoutExecuted(payoutExecuted, context.swapId);
+    } finally {
+      try {
+        if (storageError) this.emitStorageError(storageError);
+      } finally {
+        this.settlePushListener(env);
       }
-      if (refundExecuted) {
-        this.emitRefundExecuted(refundExecuted, env.swap_id ?? this.swapId);
+    }
+  }
+  async handleTerminalPush(env, context, next, payoutExecuted, refundExecuted, persistence) {
+    this.rememberTerminalOutcome(context.swapId, next, refundExecuted);
+    let storageError = null;
+    if (persistence.enabled) {
+      try {
+        await persistTransferTerminal(
+          persistence,
+          context.swapId,
+          next,
+          env.timestamp_ms,
+          refundExecuted ? "refund" : "sync"
+        );
+      } catch (error) {
+        storageError = storageErrorFromPush(error, context.swapId, refundExecuted);
+      }
+    }
+    if (storageError) {
+      this.rememberTerminalOutcome(context.swapId, next, refundExecuted, storageError);
+    }
+    if (!this.isActiveSwapContext(context)) {
+      context.swapState = next;
+      return;
+    }
+    try {
+      this.updateContextState(context, next);
+      if (payoutExecuted) this.emitPayoutExecuted(payoutExecuted, context.swapId);
+      if (refundExecuted) this.emitRefundExecuted(refundExecuted, context.swapId);
+    } finally {
+      try {
+        if (storageError) this.emitStorageError(storageError);
+      } finally {
+        this.settlePushListener(env);
       }
-      this.resolvePushListener(env);
     }
   }
-  applySwapStatus(status, coordinatorTimestampMs) {
-    const keepTerminalState = TERMINAL_SWAP_STATES.has(this.swapState) && status.state !== this.swapState;
-    if (!keepTerminalState && this.swapState !== status.state) {
-      this.swapState = status.state;
-      this.emitStateChange();
+  emitStorageError(error) {
+    for (const listener of this.storageErrorListeners) listener(error);
+    this.log(`client persistence failed: ${normalizeError(error)}`, "info");
+  }
+  applySwapStatus(context, status, coordinatorTimestampMs) {
+    const keepTerminalState = TERMINAL_SWAP_STATES.has(context.swapState) && status.state !== context.swapState;
+    if (!keepTerminalState && isTerminalSwapState(status.state)) {
+      this.rememberTerminalOutcome(context.swapId, status.state, status.withdraw_execution);
+    }
+    if (!keepTerminalState && context.swapState !== status.state) {
+      this.updateContextState(context, status.state);
     }
     for (const fragment of status.fragments_executed) {
-      this.emitPayoutExecuted(fragment, this.swapId);
+      this.emitPayoutExecuted(fragment, context.swapId);
     }
     if (status.withdraw_execution) {
-      this.emitRefundExecuted(status.withdraw_execution, this.swapId);
+      this.emitRefundExecuted(status.withdraw_execution, context.swapId);
     }
     if (status.actor_sync !== void 0) {
       for (const listener of this.normalUserActorSyncListeners) {
@@ -853,8 +1475,7 @@ var UserCoordinatorSession = class {
   emitPayoutExecuted(payload, swapId) {
     if (!swapId) return;
     const key = `${swapId}:${payload.index}:${payload.tx_signature}`;
-    if (this.emittedPayoutKeys.has(key)) return;
-    this.emittedPayoutKeys.add(key);
+    if (!this.rememberEventKey(this.emittedPayoutKeys, key)) return;
     this.log(
       `payout executed tx=${payload.tx_signature} amount=${payload.amount_lamports} final=${payload.final}`,
       "in"
@@ -866,88 +1487,150 @@ var UserCoordinatorSession = class {
   emitRefundExecuted(payload, swapId) {
     if (!swapId) return;
     const key = `${swapId}:${payload.tx_signature}`;
-    if (this.emittedRefundKeys.has(key)) return;
-    this.emittedRefundKeys.add(key);
+    if (!this.rememberEventKey(this.emittedRefundKeys, key)) return;
     this.log(`refund executed tx=${payload.tx_signature} amount=${payload.amount_lamports}`, "in");
     for (const listener of this.refundExecutedListeners) {
       listener(payload, swapId);
     }
   }
-  request(type, payload, timeoutMs) {
+  rememberEventKey(keys, key) {
+    if (keys.has(key)) return false;
+    keys.add(key);
+    if (keys.size > MAX_EVENT_DEDUP_ENTRIES_PER_KIND) {
+      const oldest = keys.values().next().value;
+      if (oldest !== void 0) keys.delete(oldest);
+    }
+    return true;
+  }
+  request(type, payload, options = {}) {
     if (this.session === null) {
       throw new TransportError("CONNECTION_LOST", "coordinator session is not connected");
     }
     return requestEnvelope(this.session, type, payload, {
-      swapId: this.swapId,
-      timeoutMs,
+      swapId: options.swapId === void 0 ? this.swapId : options.swapId,
+      timeoutMs: options.timeoutMs,
+      rejectMatchingOutOfBandErrors: options.rejectMatchingOutOfBandErrors,
+      requireNonNullResponseSwapId: options.requireNonNullResponseSwapId,
       onLog: (message, direction) => this.log(message, direction)
     });
   }
-  awaitPush(type, timeoutMs = 3e4) {
+  awaitPush(type, swapId, timeoutMs = 3e4) {
     return new Promise((resolve, reject) => {
       const timer = timeoutMs === null ? null : setTimeout(() => {
-        this.pushListeners.delete(type);
+        this.removePushListener(type, listener);
         reject(new CommandError("REJECTED_STALE_JOB", `timed out waiting for ${type} push`));
       }, timeoutMs);
-      this.pushListeners.set(type, { resolve, reject, timer });
+      const listener = { swapId, resolve, reject, timer };
+      const listeners = this.pushListeners.get(type) ?? [];
+      listeners.push(listener);
+      this.pushListeners.set(type, listeners);
     });
   }
   rejectAllPushListeners(err) {
-    for (const listener of this.pushListeners.values()) {
-      if (listener.timer) clearTimeout(listener.timer);
-      listener.reject(err);
+    for (const listeners of this.pushListeners.values()) {
+      for (const listener of listeners) {
+        if (listener.timer) clearTimeout(listener.timer);
+        listener.reject(err);
+      }
     }
     this.pushListeners.clear();
-    this.bufferDepositConfirmedUntilDelegateAck = false;
-    this.bufferedDepositConfirmed = null;
+    for (const context of this.swapContexts.values()) {
+      context.bufferDepositConfirmedUntilDelegateAck = false;
+      context.bufferedDepositConfirmed = null;
+    }
   }
   shouldBufferDepositConfirmed(env) {
-    return env.kind === EnvelopeKind.PUSH && env.type === CoordinatorMessageType.DepositConfirmed && this.bufferDepositConfirmedUntilDelegateAck;
+    const context = env.swap_id ? this.swapContexts.get(env.swap_id) : null;
+    return env.kind === EnvelopeKind.PUSH && env.type === CoordinatorMessageType.DepositConfirmed && context?.bufferDepositConfirmedUntilDelegateAck === true;
   }
   bufferDepositConfirmed(env) {
-    if (!this.bufferedDepositConfirmed) {
-      this.bufferedDepositConfirmed = env;
-      this.clearPushListenerTimer(CoordinatorMessageType.DepositConfirmed);
+    const context = env.swap_id ? this.swapContexts.get(env.swap_id) : null;
+    if (!context) return;
+    if (!context.bufferedDepositConfirmed) {
+      context.bufferedDepositConfirmed = env;
+      this.clearPushListenerTimer(CoordinatorMessageType.DepositConfirmed, context.swapId);
       this.log("buffered DepositConfirmed until DelegateAck is verified", "info");
       return;
     }
     this.log("ignored duplicate DepositConfirmed while waiting for DelegateAck", "info");
   }
-  releaseDepositConfirmedGate() {
+  async releaseDepositConfirmedGate(context) {
     const protocol = this.requireProtocol();
-    this.bufferDepositConfirmedUntilDelegateAck = false;
-    const buffered = this.bufferedDepositConfirmed;
+    context.bufferDepositConfirmedUntilDelegateAck = false;
+    const buffered = context.bufferedDepositConfirmed;
     if (!buffered) return;
-    this.bufferedDepositConfirmed = null;
-    const next = protocol.nextState(this.swapState, buffered.kind, buffered.type);
+    context.bufferedDepositConfirmed = null;
+    const next = protocol.nextState(context.swapState, buffered.kind, buffered.type);
     if (next === null) {
-      this.log(`ignored buffered DepositConfirmed in state ${this.swapState}`, "info");
+      this.log(`ignored buffered DepositConfirmed in state ${context.swapState}`, "info");
       return;
     }
-    this.swapState = next;
-    this.emitStateChange();
-    this.resolvePushListener(buffered);
-  }
-  resolvePushListener(env) {
-    const listener = this.pushListeners.get(env.type);
-    if (!listener) return;
-    this.pushListeners.delete(env.type);
+    let storageError = null;
+    try {
+      await persistTransferStatus(
+        this.clientPersistenceState(),
+        context.swapId,
+        { state: next },
+        buffered.timestamp_ms
+      );
+    } catch (error) {
+      storageError = storageErrorFromPush(error, context.swapId, null);
+    }
+    if (storageError) {
+      this.emitStorageError(storageError);
+      throw storageError;
+    }
+    if (!this.isActiveSwapContext(context)) return;
+    this.updateContextState(context, next);
+    this.settlePushListener(buffered);
+  }
+  settlePushListener(env, error) {
+    const listeners = this.pushListeners.get(env.type);
+    if (!listeners) return;
+    const index = listeners.findIndex(
+      (candidate) => candidate.swapId === void 0 || candidate.swapId === env.swap_id
+    );
+    if (index < 0) return;
+    const listener = listeners.splice(index, 1)[0];
+    if (listeners.length === 0) this.pushListeners.delete(env.type);
     if (listener.timer) clearTimeout(listener.timer);
-    listener.resolve(env);
+    if (error) listener.reject(error);
+    else listener.resolve(env);
   }
-  clearPushListenerTimer(type) {
-    const listener = this.pushListeners.get(type);
+  clearPushListenerTimer(type, swapId) {
+    const listener = this.pushListeners.get(type)?.find((candidate) => candidate.swapId === void 0 || candidate.swapId === swapId);
     if (!listener?.timer) return;
     clearTimeout(listener.timer);
     listener.timer = null;
   }
+  removePushListener(type, listener) {
+    const listeners = this.pushListeners.get(type);
+    if (!listeners) return;
+    const index = listeners.indexOf(listener);
+    if (index >= 0) listeners.splice(index, 1);
+    if (listeners.length === 0) this.pushListeners.delete(type);
+  }
+  cancelPushWaitersForSwap(swapId) {
+    for (const [type, listeners] of this.pushListeners.entries()) {
+      const remaining = listeners.filter((listener) => {
+        if (listener.swapId !== swapId) return true;
+        if (listener.timer) clearTimeout(listener.timer);
+        return false;
+      });
+      if (remaining.length === 0) {
+        this.pushListeners.delete(type);
+      } else if (remaining.length !== listeners.length) {
+        this.pushListeners.set(type, remaining);
+      }
+    }
+  }
   setSessionStatus(status) {
     this.sessionStatus = status;
     this.emitStateChange();
   }
-  emitStateChange() {
+  emitStateChange(swapId = this.swapId, swapState = this.swapState) {
     for (const listener of this.stateListeners) {
-      listener(this.swapState, this.sessionStatus);
+      listener(swapState, this.sessionStatus, swapId);
     }
   }
   log(msg, direction) {
@@ -983,28 +1666,42 @@ function toContractRequestResult(prepared) {
     delegatedAtMs: prepared.delegatedAtMs,
     syncSecret: new Uint8Array(prepared.syncSecret),
     syncSecretHex: prepared.syncSecretHex,
+    resumeSecret: new Uint8Array(prepared.resumeSecret),
+    resumeSecretHex: prepared.resumeSecretHex,
     recoveryCodeHex: prepared.recoveryCodeHex,
     policySnapshot: prepared.policySnapshot,
     delegatePolicySnapshot: prepared.delegatePolicySnapshot
   };
 }
 async function contractRequestOnSession(session, params) {
-  if (activeFunctionalContractRequests.has(session)) {
-    throw new CommandError("REJECTED_STATE", ACTIVE_CONTRACT_REQUEST_MESSAGE);
-  }
-  activeFunctionalContractRequests.add(session);
   let client = null;
   try {
-    client = new UserCoordinatorSession({
-      coordinator: getSessionState(session).pool,
-      createSession: async () => session
-    });
+    client = new UserCoordinatorSession(
+      {
+        coordinator: getSessionState(session).pool,
+        createSession: async () => session
+      },
+      false
+    );
     return await client.contractRequest(params);
   } finally {
-    activeFunctionalContractRequests.delete(session);
     client?.releaseWithoutClosing();
   }
 }
+async function resumePreDelegationOnSession(session, params) {
+  const client = new UserCoordinatorSession(
+    {
+      coordinator: getSessionState(session).pool,
+      createSession: async () => session
+    },
+    false
+  );
+  try {
+    return await client.resumePreDelegation(params);
+  } finally {
+    client.releaseWithoutClosing();
+  }
+}
 async function requestRefundOnSession(session, params) {
   const client = new UserCoordinatorSession(
     {
@@ -1057,6 +1754,12 @@ async function requestUserSync(session, swapId, syncSecret, timeoutMs) {
   );
   const payload = (await loadProtocol()).asSyncUserResponsePayload(env);
   assertSyncResponseContractId(env, payload, swapId);
+  await persistTransferStatus(
+    getSessionState(session).clientPersistence,
+    swapId,
+    payload,
+    env.timestamp_ms
+  );
   return {
     ...payload,
     coordinatorTimestampMs: env.timestamp_ms
@@ -1140,6 +1843,18 @@ function isRetryableSwapStatusReconciliationError(err) {
   if (err instanceof AttestationError) return false;
   return err instanceof CommandError && err.code === "REJECTED_STALE_JOB";
 }
+function isTerminalSwapState(state) {
+  return state === "completed" || state === "refunded" || state === "failed";
+}
+function storageErrorFromPush(error, swapId, refundExecuted) {
+  if (error instanceof StorageError) return error;
+  return new StorageError("STORAGE_NOT_AVAILABLE", "client persistence update failed", {
+    cause: error,
+    swapId,
+    phase: refundExecuted ? "refund" : "sync",
+    remoteAccepted: true
+  });
+}
 function coordinatorErrorFromEnvelope(protocol, env) {
   try {
     const payload = protocol.asErrorPayload(env);
@@ -1182,11 +1897,35 @@ async function contractRequest(session, args) {
     ...args.onSyncSecretReady !== void 0 && {
       onSyncSecretReady: args.onSyncSecretReady
     },
+    ...args.resumeSecret !== void 0 && { resumeSecret: args.resumeSecret },
+    ...args.onResumeSecretReady !== void 0 && {
+      onResumeSecretReady: args.onResumeSecretReady
+    },
+    ...args.onSwapAllocated !== void 0 && {
+      onSwapAllocated: args.onSwapAllocated
+    },
     ...args.onRecoveryCodeReady !== void 0 && {
       onRecoveryCodeReady: args.onRecoveryCodeReady
+    },
+    ...args.onDelegateShareReady !== void 0 && {
+      onDelegateShareReady: args.onDelegateShareReady
     }
   });
 }
+async function resumePreDelegation(session, args) {
+  assertAttested(session);
+  return resumePreDelegationOnSession(session, {
+    swapId: args.swapId,
+    resumeSecret: new Uint8Array(args.resumeSecret),
+    ...args.syncSecret !== void 0 && { syncSecret: new Uint8Array(args.syncSecret) },
+    recoveryCommitment: new Uint8Array(args.recoveryCommitment),
+    policySnapshot: args.policySnapshot,
+    ...args.onDelegateShareReady !== void 0 && {
+      onDelegateShareReady: args.onDelegateShareReady
+    },
+    ...args.delegateShare !== void 0 && { delegateShare: new Uint8Array(args.delegateShare) }
+  });
+}
 async function sync(session, contractId, syncSecret, timeoutMs) {
   assertAttested(session);
   return requestUserSync(session, contractId, syncSecret, timeoutMs);
@@ -1228,10 +1967,12 @@ async function requestRefund(session, args) {
   assertAttested(session);
   assertRecoveryCode(args.recoveryCode);
   return requestRefundOnSession(session, {
+    ...args.swapId !== void 0 && { swapId: args.swapId },
+    ...args.syncSecret !== void 0 && { syncSecret: new Uint8Array(args.syncSecret) },
     recoveryCode: new Uint8Array(args.recoveryCode)
   });
 }
 
-export { INSTANT_PAYOUT_WINDOW_MS, MAX_ENTRY_AMOUNT_LAMPORTS, MIN_ENTRY_AMOUNT_LAMPORTS, PAYOUT_WINDOW_MILLISECONDS_PER_SECOND, RECOVERY_CODE_BYTE_LENGTH, SUPPORTED_TOTAL_DEADLINE_MS, commitmentFromCode, contractRequest, generateRecoveryCode, recoveryCodeFromHex, recoveryCodeFromUserInput, recoveryCodeToHex, requestRefund, sync };
+export { INSTANT_PAYOUT_WINDOW_MS, MAX_ENTRY_AMOUNT_LAMPORTS, MIN_ENTRY_AMOUNT_LAMPORTS, PAYOUT_WINDOW_MILLISECONDS_PER_SECOND, RECOVERY_CODE_BYTE_LENGTH, SUPPORTED_TOTAL_DEADLINE_MS, commitmentFromCode, contractRequest, generateRecoveryCode, recoveryCodeFromHex, recoveryCodeFromUserInput, recoveryCodeToHex, requestRefund, resumePreDelegation, sync };
 //# sourceMappingURL=user.js.map
 //# sourceMappingURL=user.js.map