@invisible-labs/sdk 0.6.0-devnet.2 → 0.6.0-devnet.4

package/dist/user.js

@@ -1,12 +1,12 @@
-import { scheduledPayoutWindowSeconds } from './chunk-LBC7ALYO.js';
-import { createSession, createExponentialBackoff, validatePayoutPolicyShape, formatAjvErrors } from './chunk-7DSVN3MV.js';
-import { PRODUCT_MAX_ENTRY_LAMPORTS, PRODUCT_MIN_ENTRY_LAMPORTS } from './chunk-TQNNTV5F.js';
-import { solanaAddressFromPublicKeyBytes, publicKey, assertAttested } from './chunk-SZAYO2L5.js';
-import { CoordinatorMessageType, onEnvelope, closeProtocolRuntime, EnvelopeKind, requestEnvelope } from './chunk-XUWBGET5.js';
-import { getSessionState } from './chunk-JRMKCE3S.js';
-import './chunk-NCY4FCYU.js';
-import { TransportError, CommandError, InvalidDepositAmountError, normalizeError, PolicyValidationError, NotImplementedError, RoutingError, AttestationError } from './chunk-OHIM2YWU.js';
-export { InvalidDepositAmountError } from './chunk-OHIM2YWU.js';
+import { scheduledPayoutWindowSeconds } from './chunk-E4DCEDAG.js';
+import { validatePayoutPolicyShape, formatAjvErrors, createSession, createExponentialBackoff } from './chunk-5NNEO7IK.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-UADJCUPK.js';
+import { getSessionState } from './chunk-V5HXJRBW.js';
+import './chunk-DIA6U2CV.js';
+import { PolicyValidationError, CommandError, TransportError, InvalidDepositAmountError, normalizeError, AttestationError, RoutingError } from './chunk-GHBQF3A7.js';
+export { InvalidDepositAmountError } from './chunk-GHBQF3A7.js';
 import './chunk-VR6T6OJS.js';
 
 // src/validation/payoutPolicy.ts
@@ -171,7 +171,7 @@ function recoveryCodeFromUserInput(input) {
 var protocolPromise = null;
 var frostRuntimePromise = null;
 function loadProtocol() {
-  protocolPromise ??= import('./coordinator-7Y45MCCZ.js');
+  protocolPromise ??= import('./coordinator-ZNLGAYXD.js');
   return protocolPromise;
 }
 function loadFrostRuntime() {
@@ -185,22 +185,22 @@ var BENIGN_TRANSPORT_DROP = /* @__PURE__ */ Symbol("benignTransportDrop");
 var ALICE_ID = 1;
 var COORDINATOR_ID = 2;
 var SYNC_SECRET_BYTE_LENGTH = 32;
-var ACTIVE_CONTRACT_REQUEST_MESSAGE = "coordinator session already has an active contract";
+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 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 createCoordinatorSession(options) {
-  return new UserCoordinatorSession(options);
-}
 function isBenignTransportDrop(err) {
   return typeof err === "object" && err !== null && err[BENIGN_TRANSPORT_DROP] === true;
 }
@@ -229,8 +229,12 @@ 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();
@@ -239,12 +243,10 @@ var UserCoordinatorSession = class {
     this.coordinatorErrorListeners = /* @__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.coordinator = options.coordinator;
     this.createSessionImpl = options.createSession ?? createSession;
-    this.closeSessionAfterRefund = closeSessionAfterRefund;
+    this.closeSessionAfterOperationFailure = closeSessionAfterRefund;
   }
   onStateChange(listener) {
     this.stateListeners.add(listener);
@@ -280,51 +282,226 @@ var UserCoordinatorSession = class {
   get currentSwapId() {
     return this.swapId;
   }
+  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,
+        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;
+    }
+    this.emitStateChange(context.swapId, state);
+    if (TERMINAL_SWAP_STATES.has(state)) {
+      this.evictSwapContext(context.swapId);
+    }
+  }
+  evictSwapContext(swapId) {
+    this.statusReconciliationStops.get(swapId)?.();
+    this.statusReconciliationStops.delete(swapId);
+    const context = this.swapContexts.get(swapId);
+    if (context) {
+      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.emittedPayoutKeys.clear();
+    this.emittedRefundKeys.clear();
+  }
   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";
+      this.setCurrentContext(context);
+      let jointPublicKey;
+      let depositExpiresAtMs;
+      let coordinatorTimestampMs;
+      let delegateShare = params.delegateShare ? new Uint8Array(params.delegateShare) : void 0;
+      if (!delegateShare) {
+        const dkg = await this.runDkg(context, params.onDelegateShareReady);
+        jointPublicKey = dkg.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.bufferDepositConfirmedUntilDelegateAck = false;
+      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,
@@ -332,12 +509,15 @@ 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 (params.syncSecret !== void 0) {
       if (params.syncSecret.length !== SYNC_SECRET_BYTE_LENGTH) {
         throw new CommandError(
@@ -345,28 +525,46 @@ 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);
+    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;
@@ -391,20 +589,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());
@@ -440,7 +636,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);
@@ -449,8 +646,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 });
@@ -462,9 +663,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) {
@@ -473,33 +675,36 @@ var UserCoordinatorSession = class {
           throw new CommandError("REJECTED_STATE", "syncSecret requires swapId");
         }
         this.restoreSwapContext({ swapId, syncSecret: params.syncSecret });
+        requestSwapId = swapId;
       } else if (params.swapId) {
         const swapId = params.swapId;
         this.restoreSwapContext({ 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);
-      if (env.type === CoordinatorMessageType.WithdrawExecuted) {
-        if (env.swap_id && !this.swapId) {
-          this.swapId = env.swap_id;
         }
+        throw err;
+      }
+      if (env.type === CoordinatorMessageType.WithdrawExecuted) {
+        const resolvedSwapId2 = env.swap_id ?? requestSwapId;
+        const resolvedContext2 = resolvedSwapId2 ? this.ensureSwapContext(resolvedSwapId2) : null;
+        if (resolvedContext2) this.setCurrentContext(resolvedContext2);
         return { kind: "executed", refund: this.requireProtocol().asWithdrawExecutedPayload(env) };
       }
       if (env.type !== CoordinatorMessageType.WithdrawAccepted) {
@@ -508,29 +713,32 @@ 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;
+      const resolvedContext = resolvedSwapId ? this.ensureSwapContext(resolvedSwapId) : 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 (!resolvedContext) {
+        throw new CommandError("REJECTED_STALE_JOB", REFUND_PENDING_FINALIZATION_MESSAGE);
+      }
+      if (!resolvedContext.syncSecret) {
+        throw new CommandError("REJECTED_STALE_JOB", REFUND_PENDING_FINALIZATION_MESSAGE);
       }
-      return { kind: "executed", refund: await this.awaitRefundOutcomeFromSwapStatus() };
+      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) {
         this.close();
       }
     }
   }
-  async awaitRefundOutcomeFromSwapStatus() {
+  async awaitRefundOutcomeFromSwapStatus(context) {
     const deadline = Date.now() + DEFAULT_REFUND_OUTCOME_POLL_BUDGET_MS;
     for (; ; ) {
       const perPollTimeout = Math.min(
@@ -538,7 +746,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;
         }
@@ -548,10 +756,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);
     }
@@ -572,13 +777,19 @@ var UserCoordinatorSession = class {
       "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
@@ -589,6 +800,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;
@@ -599,105 +811,165 @@ 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,
+      swapState: "awaiting_dkg",
+      syncSecret: new Uint8Array(syncSecret),
+      resumeSecret: new Uint8Array(resumeSecret),
+      bufferDepositConfirmedUntilDelegateAck: true,
+      bufferedDepositConfirmed: null
+    };
+    this.swapContexts.set(swapId, context);
+    this.setCurrentContext(context);
+    await params.onSwapAllocated?.({
       swapId,
-      amountLamports: params.amountLamports,
-      jointPublicKey,
-      depositExpiresAtMs,
-      coordinatorTimestampMs,
-      delegatedAtMs: delegateAck.delegated_at_ms,
-      syncSecret,
       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 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"
+        );
+      }
+      this.log(`delegated at ${delegateAck.delegated_at_ms}`, "in");
+      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) {
     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);
@@ -712,10 +984,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();
@@ -735,6 +1017,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(
@@ -760,11 +1056,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);
@@ -790,30 +1081,43 @@ var UserCoordinatorSession = class {
   handleEnvelope(env) {
     const protocol = this.requireProtocol();
     this.log(`<- ${env.type} kind=${env.kind}`, "in");
+    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 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 payoutMatchesCurrentSwap = payoutExecuted !== null && context !== null;
     const refundExecuted = env.kind === EnvelopeKind.PUSH && 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,
+    const stateForEnvelope = context?.swapState ?? this.swapState;
+    const next = payoutExecuted !== null && !payoutMatchesCurrentSwap ? null : protocol.nextState(
+      stateForEnvelope,
       env.kind,
       env.type,
       payoutExecuted ? { payoutFinal: payoutExecuted.final } : void 0
     );
     if (env.kind === EnvelopeKind.PUSH && 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 ?? "none"} in state ${stateForEnvelope}`,
         "info"
       );
       return;
     }
     if (next !== null) {
-      this.swapState = next;
-      this.emitStateChange();
+      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);
@@ -825,26 +1129,25 @@ var UserCoordinatorSession = class {
       return;
     }
     if (env.kind === EnvelopeKind.PUSH) {
-      if (payoutExecuted && payoutMatchesCurrentSwap) {
-        this.emitPayoutExecuted(payoutExecuted, env.swap_id ?? this.swapId);
+      if (payoutExecuted && payoutMatchesCurrentSwap && context) {
+        this.emitPayoutExecuted(payoutExecuted, context.swapId);
       }
-      if (refundExecuted) {
-        this.emitRefundExecuted(refundExecuted, env.swap_id ?? this.swapId);
+      if (refundExecuted && context) {
+        this.emitRefundExecuted(refundExecuted, context.swapId);
       }
       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();
+  applySwapStatus(context, status, coordinatorTimestampMs) {
+    const keepTerminalState = TERMINAL_SWAP_STATES.has(context.swapState) && status.state !== context.swapState;
+    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) {
@@ -855,8 +1158,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"
@@ -868,88 +1170,133 @@ 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() {
+  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.updateContextState(context, next);
     this.resolvePushListener(buffered);
   }
   resolvePushListener(env) {
-    const listener = this.pushListeners.get(env.type);
-    if (!listener) return;
-    this.pushListeners.delete(env.type);
+    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);
   }
-  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) {
@@ -985,28 +1332,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(
     {
@@ -1016,7 +1377,7 @@ async function requestRefundOnSession(session, params) {
     false
   );
   try {
-    await client.requestRefundIntent(params);
+    const result = await client.requestRefundIntent(params);
     const requestId = client.currentSwapId;
     if (!requestId) {
       throw new CommandError(
@@ -1024,7 +1385,19 @@ async function requestRefundOnSession(session, params) {
         "refund response did not include the resolved contract id"
       );
     }
-    return { accepted: true, requestId };
+    if (result.kind === "accepted") {
+      return {
+        accepted: true,
+        requestId,
+        amountLamports: result.accepted.amount_lamports,
+        acceptedAtMs: result.accepted.accepted_at_ms
+      };
+    }
+    return {
+      accepted: true,
+      requestId,
+      amountLamports: result.refund.amount_lamports
+    };
   } finally {
     client.releaseWithoutClosing();
   }
@@ -1043,9 +1416,20 @@ async function requestUserSync(session, swapId, syncSecret, timeoutMs) {
       actor: "user",
       sync_secret: new Uint8Array(syncSecret)
     },
-    { swapId, timeoutMs }
+    { swapId, timeoutMs, rejectMatchingOutOfBandErrors: true }
   );
-  return (await loadProtocol()).asSyncUserResponsePayload(env);
+  const payload = (await loadProtocol()).asSyncUserResponsePayload(env);
+  assertSyncResponseContractId(env, payload, swapId);
+  return {
+    ...payload,
+    coordinatorTimestampMs: env.timestamp_ms
+  };
+}
+function assertSyncResponseContractId(envelope, payload, requestedSwapId) {
+  const actorSyncContractId = payload.actor_sync?.snapshot.contract_id;
+  if (envelope.swap_id !== requestedSwapId || actorSyncContractId !== void 0 && actorSyncContractId !== requestedSwapId) {
+    throw new CommandError("REJECTED_STATE", SYNC_CONTRACT_ID_MISMATCH_MESSAGE);
+  }
 }
 async function ensureFrostWasm() {
   await (await loadFrostRuntime()).ensureFrostWasm();
@@ -1150,10 +1534,10 @@ async function contractRequest(session, args) {
   assertCurrentUserContractPolicy(payoutPolicy);
   assertAttested(session);
   const destination = payoutPolicy.destinations[0];
-  const payoutSpec = payoutSpecFromPolicy(payoutPolicy, destination.address);
+  const wirePayoutSpec = wirePayoutSpecFromPolicy(payoutPolicy, destination.address);
   return contractRequestOnSession(session, {
     amountLamports: args.amountLamports,
-    payoutSpec,
+    payoutSpec: wirePayoutSpec,
     ...args.syncSecret !== void 0 && { syncSecret: args.syncSecret },
     ...args.recoveryCommitment !== void 0 && {
       recoveryCommitment: args.recoveryCommitment
@@ -1161,11 +1545,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);
@@ -1188,7 +1596,7 @@ function assertCurrentUserContractPolicy(policy) {
     }
   }
 }
-function payoutSpecFromPolicy(policy, destinationAddress) {
+function wirePayoutSpecFromPolicy(policy, destinationAddress) {
   const totalDeadlineMs = policy.totalDeadlineMs;
   if (totalDeadlineMs === void 0 || totalDeadlineMs === INSTANT_PAYOUT_WINDOW_MS) {
     return {
@@ -1207,19 +1615,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)
   });
 }
-async function getDepositAddress(_session, _requestId, _syncSecret) {
-  throw new NotImplementedError("user.getDepositAddress");
-}
-function subscribe(_session, _requestId, _syncSecret, _handler) {
-  throw new NotImplementedError("user.subscribe");
-}
-async function replayFromStorage(_session, _storage) {
-  throw new NotImplementedError("user.replayFromStorage");
-}
 
-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, createCoordinatorSession, generateRecoveryCode, getDepositAddress, isBenignTransportDrop, recoveryCodeFromHex, recoveryCodeFromUserInput, recoveryCodeToHex, replayFromStorage, requestRefund, subscribe, 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