@invisible-labs/sdk 0.6.0-devnet.1

package/dist/user.js

@@ -0,0 +1,1225 @@
+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 './chunk-VR6T6OJS.js';
+
+// src/validation/payoutPolicy.ts
+var PAYOUT_WINDOW_MILLISECONDS_PER_SECOND = 1e3;
+var INSTANT_PAYOUT_WINDOW_MS = 0;
+var SCHEDULED_PAYOUT_WINDOW_DURATIONS_MS = Object.freeze(
+  scheduledPayoutWindowSeconds().map(
+    (windowSeconds) => windowSeconds * PAYOUT_WINDOW_MILLISECONDS_PER_SECOND
+  )
+);
+var SUPPORTED_TOTAL_DEADLINE_MS = Object.freeze([
+  INSTANT_PAYOUT_WINDOW_MS,
+  ...SCHEDULED_PAYOUT_WINDOW_DURATIONS_MS
+]);
+var SUPPORTED_TOTAL_DEADLINE_MS_SET = new Set(SUPPORTED_TOTAL_DEADLINE_MS);
+Math.max(...SUPPORTED_TOTAL_DEADLINE_MS);
+var SHARE_SUM_TOLERANCE = 0.01;
+var CURRENT_USER_PAYOUT_DESTINATION_LIMIT = 1;
+var CURRENT_USER_PAYOUT_DESTINATION_LIMIT_MESSAGE = "current V0 normal-user SDK and coordinator support exactly one payout destination; multi-address receive is not supported yet";
+var CURRENT_USER_BATCH_EXCLUSION_ID_UNSUPPORTED_MESSAGE = "batchExclusionId is not supported in V0 normal-user payout requests; V1 defines it as campaign-scoped batch exclusion, never a stable actor identity";
+var CURRENT_USER_MIN_DELAY_UNSUPPORTED_MESSAGE = "destinations[*].minDelayMs is not supported in V0 normal-user payout requests";
+var CURRENT_USER_MAX_DELAY_UNSUPPORTED_MESSAGE = "destinations[*].maxDelayMs is not supported in V0 normal-user payout requests";
+var CURRENT_USER_PAYOUT_FRAGMENT_LIMIT = 1;
+var CURRENT_USER_PAYOUT_FRAGMENT_LIMIT_MESSAGE = "current SDK and coordinator support exactly one scheduled payout fragment; multi-fragment receive is not supported yet";
+function validatePayoutPolicy(input, ctx = {}) {
+  if (!validatePayoutPolicyShape(input)) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      `payout policy shape invalid: ${formatAjvErrors(validatePayoutPolicyShape.errors)}`
+    );
+  }
+  const policy = input;
+  const { destinations } = policy;
+  assertCurrentUserUnsupportedPayoutFeatures(policy);
+  assertCurrentUserPayoutDestinationLimit(destinations.length);
+  for (const { address } of destinations) {
+    publicKey(address);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const { address } of destinations) {
+    if (seen.has(address)) {
+      throw new PolicyValidationError(
+        "INVALID_PAYOUT_PLAN",
+        `duplicate payout destination: ${address}`
+      );
+    }
+    seen.add(address);
+  }
+  if (ctx.originAddress !== void 0 && seen.has(ctx.originAddress)) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      "a payout destination must not be the deposit origin"
+    );
+  }
+  const shareSum = destinations.reduce((acc, d) => acc + d.sharePercent, 0);
+  if (Math.abs(shareSum - 100) > SHARE_SUM_TOLERANCE) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      `destination shares must sum to 100, got ${shareSum}`
+    );
+  }
+  for (const d of destinations) {
+    if (d.minLamports !== void 0 && ctx.totalLamports !== void 0) {
+      const shareFloor = Math.floor(ctx.totalLamports * d.sharePercent / 100);
+      if (d.minLamports > shareFloor) {
+        throw new PolicyValidationError(
+          "INVALID_AMOUNT",
+          `minLamports (${d.minLamports}) exceeds the implied share floor (${shareFloor}) for ${d.address}`
+        );
+      }
+    }
+  }
+  if (policy.totalDeadlineMs !== void 0) {
+    if (!SUPPORTED_TOTAL_DEADLINE_MS_SET.has(policy.totalDeadlineMs)) {
+      throw new PolicyValidationError(
+        "INVALID_PAYOUT_PLAN",
+        `totalDeadlineMs (${policy.totalDeadlineMs}) must be one of [${SUPPORTED_TOTAL_DEADLINE_MS.join(", ")}] milliseconds; 0 selects instant payout`
+      );
+    }
+  }
+  return policy;
+}
+function assertCurrentUserUnsupportedPayoutFeatures(policy) {
+  if (policy.batchExclusionId !== void 0) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      CURRENT_USER_BATCH_EXCLUSION_ID_UNSUPPORTED_MESSAGE
+    );
+  }
+  for (const destination of policy.destinations) {
+    if (destination.minDelayMs !== void 0) {
+      throw new PolicyValidationError(
+        "INVALID_PAYOUT_PLAN",
+        CURRENT_USER_MIN_DELAY_UNSUPPORTED_MESSAGE
+      );
+    }
+    if (destination.maxDelayMs !== void 0) {
+      throw new PolicyValidationError(
+        "INVALID_PAYOUT_PLAN",
+        CURRENT_USER_MAX_DELAY_UNSUPPORTED_MESSAGE
+      );
+    }
+  }
+}
+function assertCurrentUserPayoutDestinationLimit(destinationCount) {
+  if (destinationCount !== CURRENT_USER_PAYOUT_DESTINATION_LIMIT) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      `${CURRENT_USER_PAYOUT_DESTINATION_LIMIT_MESSAGE}; got ${destinationCount}`
+    );
+  }
+}
+function assertCurrentUserPayoutFragmentLimit(fragmentCount) {
+  if (fragmentCount !== CURRENT_USER_PAYOUT_FRAGMENT_LIMIT) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      `${CURRENT_USER_PAYOUT_FRAGMENT_LIMIT_MESSAGE}; got ${fragmentCount}`
+    );
+  }
+}
+
+// src/user/recoveryCode.ts
+var RECOVERY_CODE_BYTE_LENGTH = 32;
+function assertRecoveryCode(code) {
+  if (code.byteLength !== RECOVERY_CODE_BYTE_LENGTH) {
+    throw new PolicyValidationError(
+      "INVALID_WITHDRAWAL_PLAN",
+      `recoveryCode must be ${RECOVERY_CODE_BYTE_LENGTH} bytes`
+    );
+  }
+}
+async function generateRecoveryCode() {
+  const code = crypto.getRandomValues(new Uint8Array(RECOVERY_CODE_BYTE_LENGTH));
+  const commitment = await commitmentFromCode(code);
+  return { code, commitment };
+}
+async function commitmentFromCode(code) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", new Uint8Array(code));
+  return new Uint8Array(hashBuffer);
+}
+function recoveryCodeToHex(code) {
+  return Array.from(code).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function recoveryCodeFromHex(hex) {
+  const expectedHexLength = RECOVERY_CODE_BYTE_LENGTH * 2;
+  if (!new RegExp(`^[0-9a-fA-F]{${expectedHexLength}}$`).test(hex)) {
+    throw new Error(
+      `recovery code must be exactly ${expectedHexLength} hex characters (${RECOVERY_CODE_BYTE_LENGTH} bytes)`
+    );
+  }
+  const bytes = new Uint8Array(RECOVERY_CODE_BYTE_LENGTH);
+  for (let i = 0; i < RECOVERY_CODE_BYTE_LENGTH; i += 1) {
+    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function recoveryCodeFromUserInput(input) {
+  return recoveryCodeFromHex(input.replace(/\s+/g, ""));
+}
+
+// src/user/coordinatorSession.ts
+var protocolPromise = null;
+var frostRuntimePromise = null;
+function loadProtocol() {
+  protocolPromise ??= import('./coordinator-7Y45MCCZ.js');
+  return protocolPromise;
+}
+function loadFrostRuntime() {
+  frostRuntimePromise ??= import('./frostRuntime-JESDHN6O.js');
+  return frostRuntimePromise;
+}
+function loadFrost() {
+  return loadFrostRuntime().then((runtime) => runtime.loadFrost());
+}
+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 DEFAULT_SWAP_STATUS_RECONCILE_INTERVAL_MS = 5e3;
+var MAX_SWAP_STATUS_RETRY_DELAY_MS = 3e4;
+var SWAP_STATUS_RETRY_MULTIPLIER = 2;
+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 REQUEST_TIMEOUT_MESSAGE = "coordinator request timed out";
+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;
+}
+function readDkgComplete(protocol, envelope) {
+  const payload = protocol.asDkgCompletePayload(envelope);
+  return {
+    jointPublicKey: payload.joint_pubkey,
+    depositExpiresAtMs: payload.deposit_expires_at_ms,
+    coordinatorTimestampMs: envelope.timestamp_ms
+  };
+}
+function tagBenignTransportDrop(err) {
+  err[BENIGN_TRANSPORT_DROP] = true;
+  return err;
+}
+function isBenignTransportDropCandidate(err) {
+  return err instanceof TransportError && err.code === "CONNECTION_LOST";
+}
+var UserCoordinatorSession = class {
+  constructor(options, closeSessionAfterRefund = true) {
+    this.protocol = null;
+    this.session = null;
+    this.unsubscribeEnvelope = null;
+    this.unsubscribeTransportState = null;
+    this.swapState = "new";
+    this.sessionStatus = "idle";
+    this.swapId = null;
+    this.syncSecret = null;
+    this.attested = false;
+    this.pushListeners = /* @__PURE__ */ new Map();
+    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.emittedPayoutKeys = /* @__PURE__ */ new Set();
+    this.emittedRefundKeys = /* @__PURE__ */ new Set();
+    this.stopStatusReconciliation = null;
+    this.bufferDepositConfirmedUntilDelegateAck = false;
+    this.bufferedDepositConfirmed = null;
+    this.coordinator = options.coordinator;
+    this.createSessionImpl = options.createSession ?? createSession;
+    this.closeSessionAfterRefund = closeSessionAfterRefund;
+  }
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  onLog(listener) {
+    this.logListeners.add(listener);
+    return () => this.logListeners.delete(listener);
+  }
+  onPayoutExecuted(listener) {
+    this.payoutExecutedListeners.add(listener);
+    return () => this.payoutExecutedListeners.delete(listener);
+  }
+  onRefundExecuted(listener) {
+    this.refundExecutedListeners.add(listener);
+    return () => this.refundExecutedListeners.delete(listener);
+  }
+  onNormalUserActorSync(listener) {
+    this.normalUserActorSyncListeners.add(listener);
+    return () => this.normalUserActorSyncListeners.delete(listener);
+  }
+  onCoordinatorError(listener) {
+    this.coordinatorErrorListeners.add(listener);
+    return () => this.coordinatorErrorListeners.delete(listener);
+  }
+  get currentSwapState() {
+    return this.swapState;
+  }
+  get currentSessionStatus() {
+    return this.sessionStatus;
+  }
+  /** @internal The resolved contract id used as the V0 refund request id. */
+  get currentSwapId() {
+    return this.swapId;
+  }
+  async runSwap(params) {
+    assertCurrentUserPayoutSpecRuntimeLimits(params.payoutSpec);
+    this.assertNoActiveContract();
+    this.setSessionStatus("connecting");
+    let completed = false;
+    try {
+      await ensureFrostWasm();
+      await this.openSession();
+      this.setSessionStatus("running");
+      const result = await this.runProtocol(params);
+      completed = true;
+      this.setSessionStatus("done");
+      return result;
+    } catch (err) {
+      const error = this.normalizeSessionError(err);
+      if (!isBenignTransportDrop(error)) {
+        this.setSessionStatus("failed");
+      }
+      throw error;
+    } finally {
+      if (!completed) {
+        this.close();
+      }
+    }
+  }
+  async contractRequest(params) {
+    assertCurrentUserPayoutSpecRuntimeLimits(params.payoutSpec);
+    this.assertNoActiveContract();
+    this.setSessionStatus("connecting");
+    try {
+      await ensureFrostWasm();
+      await this.openSession();
+      this.setSessionStatus("running");
+      const prepared = await this.prepareContract(params);
+      return toContractRequestResult(prepared);
+    } catch (err) {
+      const error = this.normalizeSessionError(err);
+      this.setSessionStatus("failed");
+      throw error;
+    }
+  }
+  /** @internal Used by the functional Session API without closing its caller-owned session. */
+  releaseWithoutClosing() {
+    this.stopStatusReconciliation?.();
+    this.stopStatusReconciliation = null;
+    this.detachSession(
+      new TransportError("CONNECTION_LOST", "coordinator session operation released"),
+      false,
+      false
+    );
+  }
+  close() {
+    this.stopStatusReconciliation?.();
+    this.stopStatusReconciliation = null;
+    this.detachSession(new TransportError("CONNECTION_LOST", "coordinator session closed"), true);
+  }
+  restoreSwapContext(params) {
+    this.swapId = params.swapId;
+    if (params.syncSecret !== void 0) {
+      if (params.syncSecret.length !== SYNC_SECRET_BYTE_LENGTH) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          `syncSecret must be ${SYNC_SECRET_BYTE_LENGTH} bytes`
+        );
+      }
+      this.syncSecret = new Uint8Array(params.syncSecret);
+    }
+  }
+  async requestSwapStatus(timeoutMs) {
+    if (!this.swapId) {
+      throw new CommandError("REJECTED_STATE", "Sync requires swapId");
+    }
+    await this.openSession();
+    const env = await this.request(
+      CoordinatorMessageType.Sync,
+      {
+        actor: "user",
+        ...this.syncSecret ? { sync_secret: this.syncSecret } : {}
+      },
+      timeoutMs
+    );
+    const status = this.requireProtocol().asSyncUserResponsePayload(env);
+    this.applySwapStatus(status, env.timestamp_ms);
+    return status;
+  }
+  startSwapStatusReconciliation(intervalMs = DEFAULT_SWAP_STATUS_RECONCILE_INTERVAL_MS) {
+    this.stopStatusReconciliation?.();
+    let stopped = false;
+    let reconciling = false;
+    let timer = null;
+    const browserWindow = typeof window === "undefined" ? null : window;
+    const browserDocument = typeof document === "undefined" ? null : document;
+    const retryBackoff = createExponentialBackoff({
+      initialDelayMs: intervalMs,
+      maxDelayMs: Math.max(MAX_SWAP_STATUS_RETRY_DELAY_MS, intervalMs),
+      multiplier: SWAP_STATUS_RETRY_MULTIPLIER,
+      jitterRatio: SWAP_STATUS_RETRY_JITTER_RATIO
+    });
+    const isVisible = () => browserDocument === null || browserDocument.visibilityState === "visible";
+    const schedule = (delayMs) => {
+      if (stopped || !isVisible()) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        void reconcile();
+      }, delayMs);
+    };
+    const reconcile = async () => {
+      if (stopped || reconciling || !isVisible()) return;
+      reconciling = true;
+      try {
+        const status = await this.requestSwapStatus();
+        retryBackoff.reset();
+        if (status.state === "completed" || status.state === "refunded" || status.state === "failed") {
+          stopped = true;
+          if (timer) clearTimeout(timer);
+        } else {
+          schedule(intervalMs);
+        }
+      } catch (err) {
+        this.log(`SwapStatus reconcile failed: ${normalizeError(err)}`, "info");
+        if (!isRetryableSwapStatusReconciliationError(err)) {
+          stopped = true;
+          if (timer) clearTimeout(timer);
+          this.close();
+          return;
+        }
+        schedule(retryBackoff.nextDelayMs());
+      } finally {
+        reconciling = false;
+      }
+    };
+    const reconcileWhenVisible = () => {
+      if (!isVisible()) return;
+      if (timer) clearTimeout(timer);
+      timer = null;
+      void reconcile();
+    };
+    const pauseWhileInactive = () => {
+      if (timer) clearTimeout(timer);
+      timer = null;
+    };
+    const handleVisibilityChange = () => {
+      if (!isVisible()) {
+        pauseWhileInactive();
+        return;
+      }
+      reconcileWhenVisible();
+    };
+    const handleFreeze = () => {
+      pauseWhileInactive();
+      this.detachSession(new TransportError("CONNECTION_LOST", "coordinator page frozen"), true);
+    };
+    browserWindow?.addEventListener("focus", reconcileWhenVisible);
+    browserWindow?.addEventListener("online", reconcileWhenVisible);
+    browserWindow?.addEventListener("pageshow", reconcileWhenVisible);
+    browserDocument?.addEventListener("visibilitychange", handleVisibilityChange);
+    browserDocument?.addEventListener("freeze", handleFreeze);
+    browserDocument?.addEventListener("resume", reconcileWhenVisible);
+    reconcileWhenVisible();
+    this.stopStatusReconciliation = () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      browserWindow?.removeEventListener("focus", reconcileWhenVisible);
+      browserWindow?.removeEventListener("online", reconcileWhenVisible);
+      browserWindow?.removeEventListener("pageshow", reconcileWhenVisible);
+      browserDocument?.removeEventListener("visibilitychange", handleVisibilityChange);
+      browserDocument?.removeEventListener("freeze", handleFreeze);
+      browserDocument?.removeEventListener("resume", reconcileWhenVisible);
+    };
+    return this.stopStatusReconciliation;
+  }
+  async requestRefund(params) {
+    const result = await this.requestRefundIntentInternal(params, { waitForFinality: true });
+    if (result.kind === "executed") return result.refund;
+    throw new CommandError("REJECTED_STALE_JOB", "refund accepted without final execution");
+  }
+  requestRefundIntent(params) {
+    return this.requestRefundIntentInternal(params, { waitForFinality: false });
+  }
+  async requestRefundIntentInternal(params, options) {
+    assertRecoveryCode(params.recoveryCode);
+    const recoveryCode = new Uint8Array(params.recoveryCode);
+    const ackTimeout = params.timeoutMs ?? 3e4;
+    let ackTimer;
+    let openedForRefund = false;
+    try {
+      if (params.syncSecret !== void 0) {
+        const swapId = params.swapId ?? this.swapId;
+        if (!swapId) {
+          throw new CommandError("REJECTED_STATE", "syncSecret requires swapId");
+        }
+        this.restoreSwapContext({ swapId, syncSecret: params.syncSecret });
+      } else if (params.swapId) {
+        const swapId = params.swapId;
+        this.restoreSwapContext({ 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
+          );
+        })
+      ]);
+      if (ackTimer) clearTimeout(ackTimer);
+      if (env.type === CoordinatorMessageType.WithdrawExecuted) {
+        if (env.swap_id && !this.swapId) {
+          this.swapId = env.swap_id;
+        }
+        return { kind: "executed", refund: this.requireProtocol().asWithdrawExecutedPayload(env) };
+      }
+      if (env.type !== CoordinatorMessageType.WithdrawAccepted) {
+        throw new CommandError(
+          "REJECTED_GUARD",
+          `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);
+      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"
+        );
+      }
+      return { kind: "executed", refund: await this.awaitRefundOutcomeFromSwapStatus() };
+    } finally {
+      if (ackTimer) clearTimeout(ackTimer);
+      recoveryCode.fill(0);
+      if (openedForRefund && this.closeSessionAfterRefund) {
+        this.close();
+      }
+    }
+  }
+  async awaitRefundOutcomeFromSwapStatus() {
+    const deadline = Date.now() + DEFAULT_REFUND_OUTCOME_POLL_BUDGET_MS;
+    for (; ; ) {
+      const perPollTimeout = Math.min(
+        REFUND_OUTCOME_PER_POLL_TIMEOUT_MS,
+        Math.max(0, deadline - Date.now())
+      );
+      try {
+        const status = await this.requestSwapStatus(perPollTimeout);
+        if (status.withdraw_execution) {
+          return status.withdraw_execution;
+        }
+      } catch (err) {
+        if (!isRequestTimeoutError(err)) {
+          throw err;
+        }
+      }
+      if (Date.now() >= deadline) {
+        throw new CommandError(
+          "REJECTED_STALE_JOB",
+          "refund accepted and pending finalization; check status again shortly"
+        );
+      }
+      await delay(REFUND_OUTCOME_POLL_INTERVAL_MS);
+    }
+  }
+  async runProtocol(params) {
+    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)
+      );
+    }
+    this.log(
+      `deposit confirmed tx=${depositPayload.tx_signature} amount=${depositPayload.amount_lamports}`,
+      "in"
+    );
+    await params.onDepositConfirmed?.({ originAddress: depositPayload.origin_address });
+    await this.requestSwapStatus();
+    return {
+      swapId: prepared.swapId,
+      jointPublicKey: prepared.jointPublicKey,
+      depositTxSignature: depositPayload.tx_signature,
+      depositObservedAtMs: depositPayload.observed_at_ms,
+      delegatedAtMs: prepared.delegatedAtMs,
+      recoveryCodeHex: prepared.recoveryCodeHex,
+      policySnapshot: prepared.policySnapshot,
+      delegatePolicySnapshot: prepared.delegatePolicySnapshot
+    };
+  }
+  async prepareContract(params) {
+    const protocol = this.requireProtocol();
+    const requestedPayoutWindowMs = params.payoutWindowMs ?? payoutWindowMsFromSpec(params.payoutSpec);
+    const payoutDeadlineMs = requestedPayoutWindowMs !== void 0 ? Date.now() + requestedPayoutWindowMs : void 0;
+    let generatedSyncSecret = null;
+    const syncSecret = params.syncSecret ? new Uint8Array(params.syncSecret) : (() => {
+      generatedSyncSecret = randomSecret32();
+      return generatedSyncSecret;
+    })();
+    if (syncSecret.length !== SYNC_SECRET_BYTE_LENGTH) {
+      throw new CommandError(
+        "REJECTED_GUARD",
+        `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) {
+      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();
+    await params.onDepositAddressReady?.({
+      swapId,
+      jointPublicKey,
+      amountLamports: params.amountLamports,
+      depositExpiresAtMs,
+      coordinatorTimestampMs
+    });
+    return {
+      requestId: swapId,
+      swapId,
+      amountLamports: params.amountLamports,
+      jointPublicKey,
+      depositExpiresAtMs,
+      coordinatorTimestampMs,
+      delegatedAtMs: delegateAck.delegated_at_ms,
+      syncSecret,
+      syncSecretHex,
+      recoveryCodeHex,
+      policySnapshot: swapPayload.policy_snapshot,
+      delegatePolicySnapshot: delegateAck.spending_policy,
+      depositConfirmedPromise
+    };
+  }
+  async runDkg() {
+    await ensureFrostWasm();
+    const protocol = this.requireProtocol();
+    const { dkgRound1 } = await loadFrost();
+    await this.request(CoordinatorMessageType.DkgInit, {});
+    this.log("DKG initialised", "info");
+    const aliceRound1State = dkgRound1(ALICE_ID);
+    const aliceRound1Bytes = aliceRound1State.round1PackageBytes();
+    const round1Resp = await this.request(CoordinatorMessageType.DkgRound1, {
+      package: aliceRound1Bytes
+    });
+    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);
+    const aliceRound2Bytes = aliceRound2State.round2PackageBytesFor(COORDINATOR_ID);
+    let aliceKeyHandle;
+    try {
+      aliceKeyHandle = aliceRound2State.intoRound3(
+        COORDINATOR_ID,
+        round1Payload.package,
+        round1Payload.round2_for_alice
+      );
+    } 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
+    });
+    const completeEnvelope = await dkgCompletePromise;
+    const complete = readDkgComplete(protocol, completeEnvelope);
+    const alicePubkey = aliceKeyHandle.groupPublicKeyBytes();
+    if (!bytesEqual(alicePubkey, complete.jointPublicKey)) {
+      throw new CommandError(
+        "REJECTED_GUARD",
+        "DKG joint public key mismatch between Alice and coordinator"
+      );
+    }
+    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 {
+      jointPublicKey: alicePubkey,
+      keyHandle: aliceKeyHandle,
+      depositExpiresAtMs: complete.depositExpiresAtMs,
+      coordinatorTimestampMs: complete.coordinatorTimestampMs
+    };
+  }
+  async openSession() {
+    if (this.hasUsableSession()) return;
+    if (this.session !== null) {
+      this.detachSession(
+        new TransportError("CONNECTION_LOST", "cached coordinator session is not usable"),
+        true
+      );
+    }
+    this.protocol = await loadProtocol();
+    const session = await this.createSessionImpl({ coordinator: this.coordinator });
+    this.session = session;
+    this.attested = true;
+    this.unsubscribeEnvelope = onEnvelope(session, (envelope) => this.handleEnvelope(envelope));
+    this.unsubscribeTransportState = getSessionState(session).transport.onStateChange((state) => {
+      if (this.session !== session) return;
+      if (state === "closing" || state === "closed") {
+        const fatalError = getSessionState(session).lastFatalError;
+        this.detachSession(
+          fatalError ?? new TransportError("CONNECTION_LOST", "coordinator transport closed"),
+          false
+        );
+      }
+    });
+    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);
+    return state.attested && state.channel !== null && state.transport.state() === "open";
+  }
+  detachSession(error, closeTransport, closeProtocolRuntime2 = true) {
+    const rejectionError = this.attested && !closeTransport && isBenignTransportDropCandidate(error) ? tagBenignTransportDrop(error) : error;
+    this.unsubscribeEnvelope?.();
+    this.unsubscribeEnvelope = null;
+    this.unsubscribeTransportState?.();
+    this.unsubscribeTransportState = null;
+    const session = this.session;
+    this.session = null;
+    this.attested = false;
+    if (session !== null) {
+      if (closeProtocolRuntime2) closeProtocolRuntime(session);
+      if (closeTransport) {
+        getSessionState(session).close();
+      }
+    }
+    this.rejectAllPushListeners(rejectionError);
+  }
+  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 (this.shouldBufferDepositConfirmed(env)) {
+      this.bufferDepositConfirmed(env);
+      return;
+    }
+    const foreignPayout = payoutExecuted !== null && !payoutMatchesCurrentSwap;
+    const next = foreignPayout ? null : protocol.nextState(
+      this.swapState,
+      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}`,
+        "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);
+        }
+      }
+      return;
+    }
+    if (env.kind === EnvelopeKind.PUSH) {
+      if (payoutExecuted && payoutMatchesCurrentSwap) {
+        this.emitPayoutExecuted(payoutExecuted, env.swap_id ?? this.swapId);
+      }
+      if (refundExecuted) {
+        this.emitRefundExecuted(refundExecuted, env.swap_id ?? this.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();
+    }
+    for (const fragment of status.fragments_executed) {
+      this.emitPayoutExecuted(fragment, this.swapId);
+    }
+    if (status.withdraw_execution) {
+      this.emitRefundExecuted(status.withdraw_execution, this.swapId);
+    }
+    if (status.actor_sync !== void 0) {
+      for (const listener of this.normalUserActorSyncListeners) {
+        listener(status.actor_sync, coordinatorTimestampMs);
+      }
+    }
+  }
+  emitPayoutExecuted(payload, swapId) {
+    if (!swapId) return;
+    const key = `${swapId}:${payload.index}:${payload.tx_signature}`;
+    if (this.emittedPayoutKeys.has(key)) return;
+    this.emittedPayoutKeys.add(key);
+    this.log(
+      `payout executed tx=${payload.tx_signature} amount=${payload.amount_lamports} final=${payload.final}`,
+      "in"
+    );
+    for (const listener of this.payoutExecutedListeners) {
+      listener(payload, swapId);
+    }
+  }
+  emitRefundExecuted(payload, swapId) {
+    if (!swapId) return;
+    const key = `${swapId}:${payload.tx_signature}`;
+    if (this.emittedRefundKeys.has(key)) return;
+    this.emittedRefundKeys.add(key);
+    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) {
+    if (this.session === null) {
+      throw new TransportError("CONNECTION_LOST", "coordinator session is not connected");
+    }
+    return requestEnvelope(this.session, type, payload, {
+      swapId: this.swapId,
+      timeoutMs,
+      onLog: (message, direction) => this.log(message, direction)
+    });
+  }
+  awaitPush(type, timeoutMs = 3e4) {
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs === null ? null : setTimeout(() => {
+        this.pushListeners.delete(type);
+        reject(new CommandError("REJECTED_STALE_JOB", `timed out waiting for ${type} push`));
+      }, timeoutMs);
+      this.pushListeners.set(type, { resolve, reject, timer });
+    });
+  }
+  rejectAllPushListeners(err) {
+    for (const listener of this.pushListeners.values()) {
+      if (listener.timer) clearTimeout(listener.timer);
+      listener.reject(err);
+    }
+    this.pushListeners.clear();
+    this.bufferDepositConfirmedUntilDelegateAck = false;
+    this.bufferedDepositConfirmed = null;
+  }
+  shouldBufferDepositConfirmed(env) {
+    return env.kind === EnvelopeKind.PUSH && env.type === CoordinatorMessageType.DepositConfirmed && this.bufferDepositConfirmedUntilDelegateAck;
+  }
+  bufferDepositConfirmed(env) {
+    if (!this.bufferedDepositConfirmed) {
+      this.bufferedDepositConfirmed = env;
+      this.clearPushListenerTimer(CoordinatorMessageType.DepositConfirmed);
+      this.log("buffered DepositConfirmed until DelegateAck is verified", "info");
+      return;
+    }
+    this.log("ignored duplicate DepositConfirmed while waiting for DelegateAck", "info");
+  }
+  releaseDepositConfirmedGate() {
+    const protocol = this.requireProtocol();
+    this.bufferDepositConfirmedUntilDelegateAck = false;
+    const buffered = this.bufferedDepositConfirmed;
+    if (!buffered) return;
+    this.bufferedDepositConfirmed = null;
+    const next = protocol.nextState(this.swapState, buffered.kind, buffered.type);
+    if (next === null) {
+      this.log(`ignored buffered DepositConfirmed in state ${this.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);
+    if (listener.timer) clearTimeout(listener.timer);
+    listener.resolve(env);
+  }
+  clearPushListenerTimer(type) {
+    const listener = this.pushListeners.get(type);
+    if (!listener?.timer) return;
+    clearTimeout(listener.timer);
+    listener.timer = null;
+  }
+  setSessionStatus(status) {
+    this.sessionStatus = status;
+    this.emitStateChange();
+  }
+  emitStateChange() {
+    for (const listener of this.stateListeners) {
+      listener(this.swapState, this.sessionStatus);
+    }
+  }
+  log(msg, direction) {
+    for (const listener of this.logListeners) {
+      listener(msg, direction);
+    }
+  }
+  normalizeSessionError(err) {
+    if (err instanceof Error) {
+      if (this.attested && isBenignTransportDropCandidate(err)) return tagBenignTransportDrop(err);
+      return err;
+    }
+    return new Error(String(err));
+  }
+  requireProtocol() {
+    if (this.protocol === null) {
+      throw new CommandError("REJECTED_STATE", "coordinator protocol is not loaded");
+    }
+    return this.protocol;
+  }
+};
+function toContractRequestResult(prepared) {
+  return {
+    accepted: true,
+    requestId: prepared.requestId,
+    state: "awaiting_deposit",
+    swapId: prepared.swapId,
+    depositAddress: solanaAddressFromPublicKeyBytes(prepared.jointPublicKey),
+    jointPublicKey: new Uint8Array(prepared.jointPublicKey),
+    amountLamports: prepared.amountLamports,
+    depositExpiresAtMs: prepared.depositExpiresAtMs,
+    coordinatorTimestampMs: prepared.coordinatorTimestampMs,
+    delegatedAtMs: prepared.delegatedAtMs,
+    syncSecret: new Uint8Array(prepared.syncSecret),
+    syncSecretHex: prepared.syncSecretHex,
+    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
+    });
+    return await client.contractRequest(params);
+  } finally {
+    activeFunctionalContractRequests.delete(session);
+    client?.releaseWithoutClosing();
+  }
+}
+async function requestRefundOnSession(session, params) {
+  const client = new UserCoordinatorSession(
+    {
+      coordinator: getSessionState(session).pool,
+      createSession: async () => session
+    },
+    false
+  );
+  try {
+    await client.requestRefundIntent(params);
+    const requestId = client.currentSwapId;
+    if (!requestId) {
+      throw new CommandError(
+        "REJECTED_STALE_JOB",
+        "refund response did not include the resolved contract id"
+      );
+    }
+    return { accepted: true, requestId };
+  } finally {
+    client.releaseWithoutClosing();
+  }
+}
+async function requestUserSync(session, swapId, syncSecret, timeoutMs) {
+  if (swapId.trim().length === 0) {
+    throw new CommandError("REJECTED_STATE", "sync requires a non-empty swapId");
+  }
+  if (syncSecret.length !== SYNC_SECRET_BYTE_LENGTH) {
+    throw new CommandError("REJECTED_GUARD", `syncSecret must be ${SYNC_SECRET_BYTE_LENGTH} bytes`);
+  }
+  const env = await requestEnvelope(
+    session,
+    CoordinatorMessageType.Sync,
+    {
+      actor: "user",
+      sync_secret: new Uint8Array(syncSecret)
+    },
+    { swapId, timeoutMs }
+  );
+  return (await loadProtocol()).asSyncUserResponsePayload(env);
+}
+async function ensureFrostWasm() {
+  await (await loadFrostRuntime()).ensureFrostWasm();
+}
+function randomSecret32() {
+  return crypto.getRandomValues(new Uint8Array(SYNC_SECRET_BYTE_LENGTH));
+}
+async function sha256Commitment(secret) {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", new Uint8Array(secret));
+  return new Uint8Array(hashBuffer);
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function payoutWindowMsFromSpec(payoutSpec) {
+  if (payoutSpec.mode === "instant") return void 0;
+  return payoutSpec.window_seconds * 1e3;
+}
+function assertCurrentUserPayoutSpecRuntimeLimits(payoutSpec) {
+  if (payoutSpec.mode === "instant") {
+    if (typeof payoutSpec.destination_address !== "string") {
+      throw new PolicyValidationError(
+        "INVALID_PAYOUT_PLAN",
+        "instant payout_spec.destination_address must be a string"
+      );
+    }
+    publicKey(payoutSpec.destination_address);
+    return;
+  }
+  if (!Array.isArray(payoutSpec.destination_addresses)) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      "scheduled payout_spec.destination_addresses must be an array"
+    );
+  }
+  assertCurrentUserPayoutDestinationLimit(payoutSpec.destination_addresses.length);
+  for (const address of payoutSpec.destination_addresses) {
+    publicKey(address);
+  }
+  assertCurrentUserPayoutFragmentLimit(payoutSpec.num_fragments);
+  if (!CURRENT_SCHEDULED_PAYOUT_WINDOW_SECONDS.has(payoutSpec.window_seconds)) {
+    throw new PolicyValidationError(
+      "INVALID_PAYOUT_PLAN",
+      `${CURRENT_SCHEDULED_PAYOUT_WINDOW_MESSAGE}; got ${payoutSpec.window_seconds}`
+    );
+  }
+}
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  let diff = 0;
+  for (let index = 0; index < a.byteLength; index += 1) {
+    diff |= a[index] ^ b[index];
+  }
+  return diff === 0;
+}
+function spendingPoliciesEqual(a, b) {
+  return a.asset === b.asset && a.entry_amount_lamports === b.entry_amount_lamports && a.total_committed_lamports === b.total_committed_lamports && a.payout_deadline_ms === b.payout_deadline_ms && a.payout_window_ms === b.payout_window_ms && a.fragment_count === b.fragment_count && a.payout_mode === b.payout_mode && a.matching_mode === b.matching_mode && a.fragmentation_allowed === b.fragmentation_allowed && a.min_fee_bps === b.min_fee_bps && a.fee_bps === b.fee_bps && a.fee_lamports === b.fee_lamports && a.net_payout_lamports === b.net_payout_lamports && payoutSchedulesEqual(a.payout_schedule, b.payout_schedule);
+}
+function payoutSchedulesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((entry, index) => entry.destination_address === b[index]?.destination_address);
+}
+function isRequestTimeoutError(err) {
+  return err instanceof CommandError && err.message.includes(REQUEST_TIMEOUT_MESSAGE);
+}
+function isRetryableSwapStatusReconciliationError(err) {
+  if (err instanceof TransportError || err instanceof RoutingError) return true;
+  if (err instanceof AttestationError) return false;
+  return err instanceof CommandError && err.code === "REJECTED_STALE_JOB";
+}
+function coordinatorErrorFromEnvelope(protocol, env) {
+  try {
+    const payload = protocol.asErrorPayload(env);
+    return coordinatorProtocolError(payload.code, payload.message, payload.failed_req_id);
+  } catch (err) {
+    return coordinatorProtocolError(
+      "ERR_INTERNAL",
+      err instanceof Error ? err.message : "coordinator sent an invalid error payload"
+    );
+  }
+}
+function coordinatorProtocolError(code, message, failedReqId) {
+  const error = new Error(message);
+  error.name = "CoordinatorProtocolError";
+  error.code = code;
+  if (failedReqId !== void 0) error.failedReqId = failedReqId;
+  return error;
+}
+
+// src/user/index.ts
+var MIN_ENTRY_AMOUNT_LAMPORTS = PRODUCT_MIN_ENTRY_LAMPORTS;
+var MAX_ENTRY_AMOUNT_LAMPORTS = PRODUCT_MAX_ENTRY_LAMPORTS;
+var CURRENT_USER_MIN_LAMPORTS_UNSUPPORTED_MESSAGE = "destinations[*].minLamports is not supported in the current normal-user wire contract";
+async function contractRequest(session, args) {
+  const payoutPolicy = validatePayoutPolicy(args.payoutPolicy, {
+    totalLamports: args.amountLamports
+  });
+  assertEntryAmount(args.amountLamports);
+  assertCurrentUserContractPolicy(payoutPolicy);
+  assertAttested(session);
+  const destination = payoutPolicy.destinations[0];
+  const payoutSpec = payoutSpecFromPolicy(payoutPolicy, destination.address);
+  return contractRequestOnSession(session, {
+    amountLamports: args.amountLamports,
+    payoutSpec,
+    ...args.syncSecret !== void 0 && { syncSecret: args.syncSecret },
+    ...args.recoveryCommitment !== void 0 && {
+      recoveryCommitment: args.recoveryCommitment
+    },
+    ...args.onSyncSecretReady !== void 0 && {
+      onSyncSecretReady: args.onSyncSecretReady
+    },
+    ...args.onRecoveryCodeReady !== void 0 && {
+      onRecoveryCodeReady: args.onRecoveryCodeReady
+    }
+  });
+}
+async function sync(session, contractId, syncSecret, timeoutMs) {
+  assertAttested(session);
+  return requestUserSync(session, contractId, syncSecret, timeoutMs);
+}
+function assertEntryAmount(amountLamports) {
+  if (!Number.isSafeInteger(amountLamports) || amountLamports < MIN_ENTRY_AMOUNT_LAMPORTS || amountLamports > MAX_ENTRY_AMOUNT_LAMPORTS) {
+    throw new PolicyValidationError(
+      "INVALID_AMOUNT",
+      `amountLamports must be an integer between ${MIN_ENTRY_AMOUNT_LAMPORTS} and ${MAX_ENTRY_AMOUNT_LAMPORTS} lamports`
+    );
+  }
+}
+function assertCurrentUserContractPolicy(policy) {
+  for (const destination of policy.destinations) {
+    if (destination.minLamports !== void 0) {
+      throw new PolicyValidationError(
+        "INVALID_PAYOUT_PLAN",
+        CURRENT_USER_MIN_LAMPORTS_UNSUPPORTED_MESSAGE
+      );
+    }
+  }
+}
+function payoutSpecFromPolicy(policy, destinationAddress) {
+  const totalDeadlineMs = policy.totalDeadlineMs;
+  if (totalDeadlineMs === void 0 || totalDeadlineMs === INSTANT_PAYOUT_WINDOW_MS) {
+    return {
+      mode: "instant",
+      destination_address: destinationAddress
+    };
+  }
+  return {
+    mode: "scheduled",
+    num_fragments: CURRENT_USER_PAYOUT_FRAGMENT_LIMIT,
+    window_seconds: totalDeadlineMs / PAYOUT_WINDOW_MILLISECONDS_PER_SECOND,
+    destination_addresses: [destinationAddress]
+  };
+}
+async function requestRefund(session, args) {
+  assertAttested(session);
+  assertRecoveryCode(args.recoveryCode);
+  return requestRefundOnSession(session, {
+    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 };
+//# sourceMappingURL=user.js.map
+//# sourceMappingURL=user.js.map