@invisible-labs/sdk 0.6.0-devnet.1

package/dist/chunk-LBC7ALYO.js

@@ -0,0 +1,3783 @@
+import Ajv2020 from 'ajv/dist/2020.js';
+
+// ../../protocol/src/coordinator/errors.ts
+var ErrorCode = {
+  /** Decoding failed (JSON parse, missing field, wrong type). */
+  ERR_INVALID_PAYLOAD: "ERR_INVALID_PAYLOAD",
+  /** A message arrived in a state where it is not allowed. */
+  ERR_UNEXPECTED_TYPE: "ERR_UNEXPECTED_TYPE",
+  /** Unknown swap_id (coordinator-side) or no swap_id assigned yet (client-side). */
+  ERR_UNKNOWN_SWAP: "ERR_UNKNOWN_SWAP",
+  /** Spending policy violated (amount cap, fee floor, deadline, ...). */
+  ERR_POLICY_VIOLATION: "ERR_POLICY_VIOLATION",
+  /** Recovery code does not match the stored commitment. */
+  ERR_INVALID_RECOVERY_CODE: "ERR_INVALID_RECOVERY_CODE",
+  /** The swap is no longer refundable (settlement in progress / completed). */
+  ERR_SWAP_NOT_REFUNDABLE: "ERR_SWAP_NOT_REFUNDABLE",
+  /** FROST DKG package was rejected (malformed, wrong round, ...). */
+  ERR_DKG_FAILURE: "ERR_DKG_FAILURE",
+  /** Catch-all for unexpected coordinator-side failures. */
+  ERR_INTERNAL: "ERR_INTERNAL",
+  /** Deposit did not satisfy coordinator validation or funding policy. */
+  ERR_INVALID_DEPOSIT: "ERR_INVALID_DEPOSIT",
+  /** Autonomous payout/refund signing failed after the swap was accepted. */
+  ERR_SETTLEMENT_FAILED: "ERR_SETTLEMENT_FAILED"
+};
+var VALID_ERROR_CODES = new Set(Object.values(ErrorCode));
+function isValidErrorCode(value) {
+  return typeof value === "string" && VALID_ERROR_CODES.has(value);
+}
+var CoordinatorError = class extends Error {
+  constructor(code, message, failed_req_id) {
+    super(`[${code}] ${message}`);
+    this.name = "CoordinatorError";
+    this.code = code;
+    this.failed_req_id = failed_req_id;
+  }
+  toPayload() {
+    const p = { code: this.code, message: this.message };
+    if (this.failed_req_id !== void 0) {
+      return { ...p, failed_req_id: this.failed_req_id };
+    }
+    return p;
+  }
+};
+
+// ../../protocol/src/coordinator/messages.ts
+var EnvelopeKind = {
+  REQUEST: "request",
+  RESPONSE: "response",
+  PUSH: "push",
+  ERROR: "error"
+};
+var VALID_KINDS = new Set(Object.values(EnvelopeKind));
+function isValidEnvelopeKind(value) {
+  return typeof value === "string" && VALID_KINDS.has(value);
+}
+var CoordinatorMessageType = {
+  // Phase A: Swap/contract setup — unified user swap-open + LP position-open (JW-372 step 8).
+  ContractRequest: "ContractRequest",
+  // Phase B: DKG (Alice ↔ TEE)
+  DkgInit: "DkgInit",
+  DkgRound1: "DkgRound1",
+  DkgRound2: "DkgRound2",
+  DkgComplete: "DkgComplete",
+  // Phase C: Delegation
+  DelegateShare: "DelegateShare",
+  DelegateAck: "DelegateAck",
+  // Phase D: Settlement lifecycle
+  DepositConfirmed: "DepositConfirmed",
+  // Unified read-only status poll (user swap status + LP position) — JW-372 step 8.
+  Sync: "Sync",
+  // Actor-safe wake-up hint; authoritative state remains the Sync response.
+  SyncRequired: "SyncRequired",
+  // LP-only liquidity top-up command — JW-372 step 8 consolidation.
+  Refill: "Refill",
+  PayoutExecuted: "PayoutExecuted",
+  // Phase E: Withdrawals - unified user Recovery Code withdrawal + LP withdrawal (JW-372 step 8).
+  WithdrawRequest: "WithdrawRequest",
+  // Intake ack for the user WithdrawRequest arm: the durable scheduler/matcher/
+  // executor/confirmer pipeline owns the terminal outcome, surfaced via Sync.
+  WithdrawAccepted: "WithdrawAccepted",
+  // User withdrawal execution/replay surface (push or WithdrawAccepted-flow response).
+  WithdrawExecuted: "WithdrawExecuted",
+  // LP owner-authenticated command surface.
+  LpCommand: "LpCommand",
+  // Errors
+  Error: "Error"
+};
+var VALID_TYPES = new Set(Object.values(CoordinatorMessageType));
+function isValidMessageType(value) {
+  return typeof value === "string" && VALID_TYPES.has(value);
+}
+var KIND_BY_TYPE = {
+  // Pure request/response
+  ContractRequest: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  DkgInit: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  DkgRound1: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  DkgRound2: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  DelegateShare: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  Sync: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  Refill: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  // request (user refund + LP redeem) + response (the synchronous LP redeem result).
+  WithdrawRequest: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  LpCommand: /* @__PURE__ */ new Set([EnvelopeKind.REQUEST, EnvelopeKind.RESPONSE]),
+  // Response only: intake ack for WithdrawRequest.
+  WithdrawAccepted: /* @__PURE__ */ new Set([EnvelopeKind.RESPONSE]),
+  // Push only
+  DkgComplete: /* @__PURE__ */ new Set([EnvelopeKind.PUSH]),
+  DelegateAck: /* @__PURE__ */ new Set([EnvelopeKind.PUSH]),
+  DepositConfirmed: /* @__PURE__ */ new Set([EnvelopeKind.PUSH]),
+  PayoutExecuted: /* @__PURE__ */ new Set([EnvelopeKind.PUSH]),
+  SyncRequired: /* @__PURE__ */ new Set([EnvelopeKind.PUSH]),
+  // Mixed: response to WithdrawRequest replay OR push (auto-withdrawal triggered by deadline)
+  WithdrawExecuted: /* @__PURE__ */ new Set([EnvelopeKind.RESPONSE, EnvelopeKind.PUSH]),
+  // Errors
+  Error: /* @__PURE__ */ new Set([EnvelopeKind.ERROR])
+};
+function isAllowedKindForType(kind, type) {
+  return KIND_BY_TYPE[type].has(kind);
+}
+var MessageDirection = {
+  CLIENT_TO_COORDINATOR: "c2co",
+  COORDINATOR_TO_CLIENT: "co2c",
+  BIDIRECTIONAL: "both"
+};
+var DIRECTION_BY_TYPE = {
+  // Client-initiated
+  ContractRequest: MessageDirection.BIDIRECTIONAL,
+  // request c→co, response co→c
+  DkgInit: MessageDirection.BIDIRECTIONAL,
+  DkgRound1: MessageDirection.BIDIRECTIONAL,
+  DkgRound2: MessageDirection.BIDIRECTIONAL,
+  DelegateShare: MessageDirection.BIDIRECTIONAL,
+  Sync: MessageDirection.BIDIRECTIONAL,
+  Refill: MessageDirection.BIDIRECTIONAL,
+  WithdrawRequest: MessageDirection.BIDIRECTIONAL,
+  // user withdrawal c→co (ack via WithdrawAccepted); LP withdrawal c→co + co→c
+  LpCommand: MessageDirection.BIDIRECTIONAL,
+  // Coordinator-initiated (push) or coordinator response without matching request
+  DkgComplete: MessageDirection.COORDINATOR_TO_CLIENT,
+  DelegateAck: MessageDirection.COORDINATOR_TO_CLIENT,
+  DepositConfirmed: MessageDirection.COORDINATOR_TO_CLIENT,
+  PayoutExecuted: MessageDirection.COORDINATOR_TO_CLIENT,
+  SyncRequired: MessageDirection.COORDINATOR_TO_CLIENT,
+  WithdrawExecuted: MessageDirection.COORDINATOR_TO_CLIENT,
+  // both response & push are co→c
+  WithdrawAccepted: MessageDirection.COORDINATOR_TO_CLIENT,
+  // response ack to WithdrawRequest
+  // Errors can flow either way (validation can fail on either side)
+  Error: MessageDirection.BIDIRECTIONAL
+};
+
+// ../../protocol/src/coordinator/schema.generated.ts
+var COORDINATOR_BINARY_FIELD_NAMES = [
+  "auth_public_key",
+  "coordinator_attestation_hash",
+  "delegated_share",
+  "joint_pubkey",
+  "nonce",
+  "package",
+  "recovery_code",
+  "recovery_commitment",
+  "redemption_commitment",
+  "refill_public_key",
+  "round2_for_alice",
+  "round2_for_lp",
+  "share",
+  "signature",
+  "sync_commitment",
+  "sync_secret"
+];
+var COORDINATOR_SCHEMA_PAYLOAD_CATEGORIES = {
+  "request:ContractRequest": "request",
+  "response:ContractRequest": "response",
+  "request:DkgInit": "request",
+  "response:DkgInit": "response",
+  "request:DkgRound1": "request",
+  "response:DkgRound1": "response",
+  "request:DkgRound2": "request",
+  "response:DkgRound2": "response",
+  "push:DkgComplete": "push",
+  "request:DelegateShare": "request",
+  "response:DelegateShare": "response",
+  "push:DelegateAck": "push",
+  "push:DepositConfirmed": "push",
+  "request:Sync": "request",
+  "response:Sync": "response",
+  "push:SyncRequired": "push",
+  "request:Refill": "request",
+  "response:Refill": "response",
+  "push:PayoutExecuted": "push",
+  "request:WithdrawRequest": "request",
+  "response:WithdrawRequest": "response",
+  "response:WithdrawExecuted": "response",
+  "push:WithdrawExecuted": "push",
+  "response:WithdrawAccepted": "response",
+  "request:LpCommand": "request",
+  "response:LpCommand": "response",
+  "error:Error": "error"
+};
+
+// ../../protocol/src/coordinator/payloads.ts
+var VALID_SWAP_STATES = /* @__PURE__ */ new Set([
+  "new",
+  "awaiting_dkg",
+  "awaiting_deposit",
+  "awaiting_delegation",
+  "ready_for_settlement",
+  "settling",
+  "completed",
+  "refunded",
+  "failed"
+]);
+function isValidSwapState(value) {
+  return typeof value === "string" && VALID_SWAP_STATES.has(value);
+}
+function payloadCategory(kind, type) {
+  const key = `${kind}:${type}`;
+  return COORDINATOR_SCHEMA_PAYLOAD_CATEGORIES[key] ?? null;
+}
+
+// ../../protocol/src/coordinator/payout-windows.json
+var payout_windows_default = [
+  {
+    id: "instant",
+    label: "Instant",
+    mode: "instant",
+    window_seconds: null
+  },
+  {
+    id: "1h",
+    label: "1h",
+    mode: "scheduled",
+    window_seconds: 3600
+  },
+  {
+    id: "24h",
+    label: "24h",
+    mode: "scheduled",
+    window_seconds: 86400
+  },
+  {
+    id: "7d",
+    label: "7 days",
+    mode: "scheduled",
+    window_seconds: 604800
+  }
+];
+
+// ../../protocol/src/coordinator/payoutWindows.ts
+var DEFAULT_PAYOUT_WINDOW_ID = "instant";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validatePayoutWindowOptions(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error("payout window manifest must be a non-empty array");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const scheduledWindowSeconds = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    if (!isRecord(item)) {
+      throw new Error(`payout window manifest entry ${index} must be an object`);
+    }
+    const { id, label, mode, window_seconds: windowSeconds } = item;
+    if (typeof id !== "string" || id.trim() === "") {
+      throw new Error(`payout window manifest entry ${index} has invalid id`);
+    }
+    if (ids.has(id)) {
+      throw new Error(`payout window manifest has duplicate id ${id}`);
+    }
+    ids.add(id);
+    if (typeof label !== "string" || label.trim() === "") {
+      throw new Error(`payout window manifest entry ${id} has invalid label`);
+    }
+    if (mode === "instant") {
+      if (windowSeconds !== null) {
+        throw new Error(`instant payout window ${id} must not define window_seconds`);
+      }
+      return { id, label, mode, window_seconds: null };
+    }
+    if (mode === "scheduled") {
+      if (typeof windowSeconds !== "number" || !Number.isInteger(windowSeconds) || windowSeconds <= 0) {
+        throw new Error(`scheduled payout window ${id} has invalid window_seconds`);
+      }
+      if (scheduledWindowSeconds.has(windowSeconds)) {
+        throw new Error(`duplicate scheduled payout window ${windowSeconds}s`);
+      }
+      scheduledWindowSeconds.add(windowSeconds);
+      return { id, label, mode, window_seconds: windowSeconds };
+    }
+    throw new Error(`payout window manifest entry ${id} has unsupported mode`);
+  });
+}
+var PAYOUT_WINDOW_OPTIONS = validatePayoutWindowOptions(payout_windows_default);
+function payoutWindowOptionById(id) {
+  return PAYOUT_WINDOW_OPTIONS.find((option) => option.id === id);
+}
+function isPayoutWindowId(id) {
+  return payoutWindowOptionById(id) !== void 0;
+}
+function payoutWindowLabelForId(id) {
+  return payoutWindowOptionById(id)?.label ?? id;
+}
+function scheduledPayoutWindowOptions() {
+  return PAYOUT_WINDOW_OPTIONS.filter(
+    (option) => option.mode === "scheduled" && option.window_seconds !== null
+  );
+}
+function scheduledPayoutWindowSeconds() {
+  return scheduledPayoutWindowOptions().map((option) => option.window_seconds);
+}
+
+// ../../protocol/src/coordinator/state.ts
+var INITIAL_STATE = "new";
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "completed",
+  "refunded",
+  "failed"
+]);
+var TRANSITIONS = [
+  // --- new ---
+  // No swap_id yet. ContractRequest response assigns the swap_id and opens
+  // the DKG phase.
+  ["new", "response", "ContractRequest", "awaiting_dkg"],
+  // --- awaiting_dkg ---
+  // DKG rounds happen over several request/response exchanges. None of
+  // them move the phase forward by themselves; only the DkgComplete push
+  // transitions to awaiting_deposit.
+  ["awaiting_dkg", "response", "DkgInit", "awaiting_dkg"],
+  ["awaiting_dkg", "response", "DkgRound1", "awaiting_dkg"],
+  ["awaiting_dkg", "response", "DkgRound2", "awaiting_dkg"],
+  ["awaiting_dkg", "push", "DkgComplete", "awaiting_deposit"],
+  // --- awaiting_deposit ---
+  // DKG is done; the client delegates recovery/signing material before showing
+  // the fundable address. DelegateShare response only acknowledges request
+  // receipt. The client must observe DelegateAck before accepting a deposit
+  // confirmation as the next protocol step.
+  ["awaiting_deposit", "response", "DelegateShare", "awaiting_delegate_ack"],
+  ["awaiting_delegate_ack", "push", "DelegateAck", "awaiting_deposit"],
+  ["awaiting_deposit", "push", "DepositConfirmed", "ready_for_settlement"],
+  // --- delegation ---
+  // Older or restored sessions can still report awaiting_delegation when a
+  // deposit was observed before delegation. DelegateShare response is only
+  // request receipt; DelegateAck is the policy-bound acknowledgement.
+  ["awaiting_delegation", "response", "DelegateShare", "awaiting_delegate_ack_after_deposit"],
+  ["awaiting_delegate_ack_after_deposit", "push", "DelegateAck", "ready_for_settlement"],
+  ["awaiting_delegation", "push", "DelegateAck", "ready_for_settlement"],
+  // --- ready_for_settlement ---
+  // Coordinator can start executing fragments at any time. Each
+  // executed fragment is pushed; we move to `settling` on the first one.
+  // Completion is triggered by a PayoutExecuted push with `final: true`
+  // (handled as a special case in nextState, not in this table).
+  ["ready_for_settlement", "push", "PayoutExecuted", "settling"],
+  // --- settling ---
+  // More fragments may arrive. `settling` stays `settling` until the
+  // coordinator pushes a PayoutExecuted with `final: true` (see nextState).
+  ["settling", "push", "PayoutExecuted", "settling"],
+  // --- Withdrawal path (can be triggered from several states) ---
+  // WithdrawExecuted as a response to WithdrawRequest replay, OR as an
+  // unsolicited push (auto_deadline). Either way, terminal state is `refunded`.
+  ["awaiting_deposit", "response", "WithdrawExecuted", "refunded"],
+  ["awaiting_delegate_ack", "response", "WithdrawExecuted", "refunded"],
+  ["awaiting_delegation", "response", "WithdrawExecuted", "refunded"],
+  ["awaiting_delegate_ack_after_deposit", "response", "WithdrawExecuted", "refunded"],
+  ["ready_for_settlement", "response", "WithdrawExecuted", "refunded"],
+  ["settling", "response", "WithdrawExecuted", "refunded"],
+  ["awaiting_deposit", "push", "WithdrawExecuted", "refunded"],
+  ["awaiting_delegate_ack", "push", "WithdrawExecuted", "refunded"],
+  ["awaiting_delegation", "push", "WithdrawExecuted", "refunded"],
+  ["awaiting_delegate_ack_after_deposit", "push", "WithdrawExecuted", "refunded"],
+  ["ready_for_settlement", "push", "WithdrawExecuted", "refunded"],
+  ["settling", "push", "WithdrawExecuted", "refunded"]
+];
+var transitionMap = /* @__PURE__ */ new Map();
+for (const [from, kind, type, to] of TRANSITIONS) {
+  transitionMap.set(triggerKey(from, kind, type), to);
+}
+function triggerKey(state, kind, type) {
+  return `${state}|${kind}|${type}`;
+}
+function nextState(current, kind, type, hint) {
+  if (TERMINAL_STATES.has(current)) return null;
+  if (kind === "push" && type === "PayoutExecuted" && hint?.payoutFinal === true && (current === "ready_for_settlement" || current === "settling")) {
+    return "completed";
+  }
+  return transitionMap.get(triggerKey(current, kind, type)) ?? null;
+}
+function isAllowedInState(current, kind, type) {
+  if (TERMINAL_STATES.has(current)) {
+    return type === "Sync" && (kind === "request" || kind === "response");
+  }
+  if (type === "Error") return true;
+  if (current === "new") {
+    return type === "ContractRequest" && (kind === "request" || kind === "response");
+  }
+  if (type === "Sync") return true;
+  if (kind === "request") {
+    if (type === "WithdrawRequest") {
+      return current === "awaiting_deposit" || current === "awaiting_delegate_ack" || current === "awaiting_delegation" || current === "awaiting_delegate_ack_after_deposit" || current === "ready_for_settlement" || current === "settling";
+    }
+    if (current === "awaiting_dkg") {
+      return type === "DkgInit" || type === "DkgRound1" || type === "DkgRound2";
+    }
+    if (current === "awaiting_deposit" || current === "awaiting_delegation") {
+      return type === "DelegateShare";
+    }
+    return false;
+  }
+  return transitionMap.has(triggerKey(current, kind, type));
+}
+
+// ../../protocol/src/coordinator/coordinator-envelope.schema.json
+var coordinator_envelope_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://invisible.local/schemas/coordinator-envelope.v2.schema.json",
+  title: "Invisible Coordinator Envelope v2",
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "kind", "type", "swap_id", "req_id", "timestamp_ms", "payload"],
+  properties: {
+    version: {
+      const: 2
+    },
+    kind: {
+      enum: ["request", "response", "push", "error"]
+    },
+    type: {
+      enum: [
+        "ContractRequest",
+        "DkgInit",
+        "DkgRound1",
+        "DkgRound2",
+        "DkgComplete",
+        "DelegateShare",
+        "DelegateAck",
+        "DepositConfirmed",
+        "Sync",
+        "SyncRequired",
+        "Refill",
+        "PayoutExecuted",
+        "WithdrawRequest",
+        "WithdrawExecuted",
+        "WithdrawAccepted",
+        "LpCommand",
+        "Error"
+      ]
+    },
+    swap_id: {
+      anyOf: [
+        {
+          type: "null"
+        },
+        {
+          type: "string",
+          minLength: 1,
+          maxLength: 128
+        }
+      ]
+    },
+    req_id: {
+      $ref: "#/$defs/u32"
+    },
+    timestamp_ms: {
+      $ref: "#/$defs/safeUInt"
+    },
+    payload: {
+      type: "object"
+    }
+  },
+  allOf: [
+    {
+      oneOf: [
+        {
+          title: "ContractRequest request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "ContractRequest"
+            },
+            payload: {
+              $ref: "#/$defs/contractRequestRequest"
+            }
+          }
+        },
+        {
+          title: "ContractRequest response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "ContractRequest"
+            },
+            payload: {
+              $ref: "#/$defs/contractRequestResponse"
+            }
+          }
+        },
+        {
+          title: "DkgInit request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "DkgInit"
+            },
+            payload: {
+              $ref: "#/$defs/emptyObject"
+            }
+          }
+        },
+        {
+          title: "DkgInit response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "DkgInit"
+            },
+            payload: {
+              $ref: "#/$defs/dkgInitResponse"
+            }
+          }
+        },
+        {
+          title: "DkgRound1 request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "DkgRound1"
+            },
+            payload: {
+              $ref: "#/$defs/dkgRoundPackage"
+            }
+          }
+        },
+        {
+          title: "DkgRound1 response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "DkgRound1"
+            },
+            payload: {
+              $ref: "#/$defs/dkgRound1Response"
+            }
+          }
+        },
+        {
+          title: "DkgRound2 request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "DkgRound2"
+            },
+            payload: {
+              $ref: "#/$defs/dkgRoundPackage"
+            }
+          }
+        },
+        {
+          title: "DkgRound2 response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "DkgRound2"
+            },
+            payload: {
+              $ref: "#/$defs/dkgRoundPackage"
+            }
+          }
+        },
+        {
+          title: "DkgComplete push",
+          properties: {
+            kind: {
+              const: "push"
+            },
+            type: {
+              const: "DkgComplete"
+            },
+            payload: {
+              $ref: "#/$defs/dkgComplete"
+            }
+          }
+        },
+        {
+          title: "DelegateShare request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "DelegateShare"
+            },
+            payload: {
+              $ref: "#/$defs/delegateShare"
+            }
+          }
+        },
+        {
+          title: "DelegateShare response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "DelegateShare"
+            },
+            payload: {
+              $ref: "#/$defs/delegateShareResponse"
+            }
+          }
+        },
+        {
+          title: "DelegateAck push",
+          properties: {
+            kind: {
+              const: "push"
+            },
+            type: {
+              const: "DelegateAck"
+            },
+            payload: {
+              $ref: "#/$defs/delegateAck"
+            }
+          }
+        },
+        {
+          title: "DepositConfirmed push",
+          properties: {
+            kind: {
+              const: "push"
+            },
+            type: {
+              const: "DepositConfirmed"
+            },
+            payload: {
+              $ref: "#/$defs/depositConfirmed"
+            }
+          }
+        },
+        {
+          title: "Sync request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "Sync"
+            },
+            payload: {
+              $ref: "#/$defs/syncRequest"
+            }
+          }
+        },
+        {
+          title: "Sync response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "Sync"
+            },
+            payload: {
+              $ref: "#/$defs/syncResponse"
+            }
+          }
+        },
+        {
+          title: "SyncRequired push",
+          properties: {
+            kind: {
+              const: "push"
+            },
+            type: {
+              const: "SyncRequired"
+            },
+            payload: {
+              $ref: "#/$defs/syncRequired"
+            }
+          }
+        },
+        {
+          title: "Refill request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "Refill"
+            },
+            swap_id: {
+              type: "null"
+            },
+            payload: {
+              $ref: "#/$defs/refillRequest"
+            }
+          }
+        },
+        {
+          title: "Refill response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "Refill"
+            },
+            swap_id: {
+              type: "null"
+            },
+            payload: {
+              $ref: "#/$defs/lpPositionResponse"
+            }
+          }
+        },
+        {
+          title: "PayoutExecuted push",
+          properties: {
+            kind: {
+              const: "push"
+            },
+            type: {
+              const: "PayoutExecuted"
+            },
+            payload: {
+              $ref: "#/$defs/executedFragment"
+            }
+          }
+        },
+        {
+          title: "WithdrawRequest request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "WithdrawRequest"
+            },
+            payload: {
+              $ref: "#/$defs/withdrawRequestRequest"
+            }
+          }
+        },
+        {
+          title: "WithdrawRequest response",
+          $comment: "Only the LP withdrawal arm gets a synchronous WithdrawRequest-typed response (the withdrawal-execution case). The user arm is acknowledged via WithdrawAccepted; replayed or terminal recovery outcomes use WithdrawExecuted / withdraw_execution.",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "WithdrawRequest"
+            },
+            swap_id: {
+              type: "null"
+            },
+            payload: {
+              $ref: "#/$defs/lpWithdrawalExecutionResponse"
+            }
+          }
+        },
+        {
+          title: "WithdrawExecuted response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "WithdrawExecuted"
+            },
+            payload: {
+              $ref: "#/$defs/withdrawExecuted"
+            }
+          }
+        },
+        {
+          title: "WithdrawExecuted push",
+          properties: {
+            kind: {
+              const: "push"
+            },
+            type: {
+              const: "WithdrawExecuted"
+            },
+            payload: {
+              $ref: "#/$defs/withdrawExecuted"
+            }
+          }
+        },
+        {
+          title: "WithdrawAccepted response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "WithdrawAccepted"
+            },
+            payload: {
+              $ref: "#/$defs/withdrawAccepted"
+            }
+          }
+        },
+        {
+          title: "LpCommand request",
+          properties: {
+            kind: {
+              const: "request"
+            },
+            type: {
+              const: "LpCommand"
+            },
+            swap_id: {
+              type: "null"
+            },
+            payload: {
+              $ref: "#/$defs/lpSignedCommand"
+            }
+          },
+          allOf: [
+            {
+              $comment: "Verb actions are routed under their own envelope type (e.g. Sync). The LpCommand envelope only carries the LP lifecycle actions.",
+              type: "object",
+              properties: {
+                payload: {
+                  type: "object",
+                  properties: {
+                    command: {
+                      type: "object",
+                      properties: {
+                        action: {
+                          enum: [
+                            "dkg_init",
+                            "dkg_round1",
+                            "dkg_round2",
+                            "dkg_finalize",
+                            "funding_plan",
+                            "funding_confirmation",
+                            "make_available",
+                            "reconcile_funding",
+                            "prepare_top_up",
+                            "top_up_status"
+                          ]
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        },
+        {
+          title: "LpCommand response",
+          properties: {
+            kind: {
+              const: "response"
+            },
+            type: {
+              const: "LpCommand"
+            },
+            swap_id: {
+              type: "null"
+            },
+            payload: {
+              $ref: "#/$defs/lpCommandLifecycleResponse"
+            }
+          }
+        },
+        {
+          title: "Error envelope",
+          properties: {
+            kind: {
+              const: "error"
+            },
+            type: {
+              const: "Error"
+            },
+            payload: {
+              $ref: "#/$defs/errorPayload"
+            }
+          }
+        }
+      ]
+    }
+  ],
+  $defs: {
+    safeUInt: {
+      type: "integer",
+      minimum: 0,
+      maximum: 9007199254740991
+    },
+    positiveSafeUInt: {
+      type: "integer",
+      minimum: 1,
+      maximum: 9007199254740991
+    },
+    entryAmountLamports: {
+      type: "integer",
+      minimum: 4e8,
+      maximum: 1e11
+    },
+    u32: {
+      type: "integer",
+      minimum: 0,
+      maximum: 4294967295
+    },
+    lpShardIndex: {
+      type: "integer",
+      minimum: 0,
+      maximum: 299
+    },
+    lpShardCount: {
+      type: "integer",
+      minimum: 0,
+      maximum: 300
+    },
+    positiveU32: {
+      type: "integer",
+      minimum: 1,
+      maximum: 4294967295
+    },
+    string: {
+      type: "string",
+      minLength: 1
+    },
+    base64urlBytes: {
+      type: "string",
+      minLength: 2,
+      pattern: "^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}|[A-Za-z0-9_-]{3})?$"
+    },
+    base64url32Bytes: {
+      type: "string",
+      minLength: 43,
+      maxLength: 43,
+      pattern: "^[A-Za-z0-9_-]{43}$"
+    },
+    emptyObject: {
+      type: "object",
+      additionalProperties: false,
+      properties: {}
+    },
+    syncRequest: {
+      oneOf: [
+        {
+          $ref: "#/$defs/syncUserRequest"
+        },
+        {
+          $ref: "#/$defs/syncLpRequest"
+        }
+      ]
+    },
+    syncUserRequest: {
+      type: "object",
+      additionalProperties: false,
+      required: ["actor"],
+      properties: {
+        actor: {
+          const: "user"
+        },
+        sync_secret: {
+          $ref: "#/$defs/base64url32Bytes"
+        }
+      }
+    },
+    syncLpRequest: {
+      type: "object",
+      additionalProperties: false,
+      required: ["actor", "command", "signature"],
+      properties: {
+        actor: {
+          const: "lp"
+        },
+        command: {
+          $ref: "#/$defs/lpCommand"
+        },
+        signature: {
+          $ref: "#/$defs/base64url64Bytes"
+        }
+      },
+      allOf: [
+        {
+          $comment: "The Sync verb carries the LP position_get command.",
+          type: "object",
+          properties: {
+            command: {
+              type: "object",
+              properties: {
+                action: {
+                  const: "position_get"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    refillRequest: {
+      $comment: "The Refill verb is LP-only: an LP-signed refill command. There is no user/protocol actor.",
+      type: "object",
+      additionalProperties: false,
+      required: ["actor", "command", "signature"],
+      properties: {
+        actor: {
+          const: "lp"
+        },
+        command: {
+          $ref: "#/$defs/lpCommand"
+        },
+        signature: {
+          $ref: "#/$defs/base64url64Bytes"
+        }
+      },
+      allOf: [
+        {
+          type: "object",
+          properties: {
+            command: {
+              type: "object",
+              properties: {
+                action: {
+                  const: "refill"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    swapRequest: {
+      $comment: "The user arm of the ContractRequest verb: open a swap/contract on the Noise session.",
+      type: "object",
+      additionalProperties: false,
+      required: ["actor", "amount_lamports", "payout_spec", "sync_commitment"],
+      properties: {
+        actor: {
+          const: "user"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/entryAmountLamports"
+        },
+        payout_deadline_ms: {
+          description: "Optional legacy absolute request deadline. Scheduled payout_spec.window_seconds selects the supported scheduled window.",
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        payout_spec: {
+          $ref: "#/$defs/payoutSpec"
+        },
+        sync_commitment: {
+          $ref: "#/$defs/base64url32Bytes"
+        }
+      }
+    },
+    contractRequestRequest: {
+      oneOf: [
+        {
+          $ref: "#/$defs/swapRequest"
+        },
+        {
+          $ref: "#/$defs/contractRequestLpRequest"
+        }
+      ]
+    },
+    contractRequestLpRequest: {
+      $comment: "The LP arm of the ContractRequest verb: an LP-signed position_open command.",
+      type: "object",
+      additionalProperties: false,
+      required: ["actor", "command", "signature"],
+      properties: {
+        actor: {
+          const: "lp"
+        },
+        command: {
+          $ref: "#/$defs/lpCommand"
+        },
+        signature: {
+          $ref: "#/$defs/base64url64Bytes"
+        }
+      },
+      allOf: [
+        {
+          type: "object",
+          properties: {
+            command: {
+              type: "object",
+              properties: {
+                action: {
+                  const: "position_open"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    contractRequestResponse: {
+      oneOf: [
+        {
+          $ref: "#/$defs/swapRequestResponse"
+        },
+        {
+          $ref: "#/$defs/lpPositionResponse"
+        }
+      ]
+    },
+    payoutSpec: {
+      oneOf: [
+        {
+          $ref: "#/$defs/instantPayoutSpec"
+        },
+        {
+          $ref: "#/$defs/scheduledPayoutSpec"
+        }
+      ]
+    },
+    instantPayoutSpec: {
+      type: "object",
+      additionalProperties: false,
+      required: ["mode", "destination_address"],
+      properties: {
+        mode: {
+          const: "instant"
+        },
+        destination_address: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    scheduledPayoutSpec: {
+      type: "object",
+      additionalProperties: false,
+      required: ["mode", "num_fragments", "window_seconds", "destination_addresses"],
+      properties: {
+        mode: {
+          const: "scheduled"
+        },
+        num_fragments: {
+          type: "integer",
+          minimum: 1,
+          maximum: 1
+        },
+        window_seconds: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        destination_addresses: {
+          type: "array",
+          minItems: 1,
+          maxItems: 1,
+          items: {
+            $ref: "#/$defs/string"
+          }
+        }
+      }
+    },
+    spendingPolicyDestination: {
+      type: "object",
+      additionalProperties: false,
+      required: ["destination_address"],
+      properties: {
+        destination_address: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    spendingPolicySnapshot: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "asset",
+        "entry_amount_lamports",
+        "total_committed_lamports",
+        "payout_deadline_ms",
+        "payout_schedule",
+        "fragment_count",
+        "payout_mode",
+        "matching_mode",
+        "fragmentation_allowed",
+        "min_fee_bps",
+        "fee_bps",
+        "fee_lamports",
+        "net_payout_lamports"
+      ],
+      allOf: [
+        {
+          oneOf: [
+            {
+              properties: {
+                payout_mode: {
+                  const: "instant"
+                }
+              }
+            },
+            {
+              required: ["payout_window_ms"],
+              properties: {
+                payout_mode: {
+                  const: "scheduled"
+                },
+                payout_window_ms: {
+                  $ref: "#/$defs/positiveSafeUInt"
+                }
+              }
+            }
+          ]
+        }
+      ],
+      properties: {
+        asset: {
+          const: "SOL"
+        },
+        entry_amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        total_committed_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        payout_deadline_ms: {
+          description: "Pre-reservation policy deadline. For scheduled payout_mode, do not treat this as the post-reservation execution SLA; payout_window_ms is the selected window.",
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        payout_window_ms: {
+          description: "Selected scheduled payout window in milliseconds. For scheduled payout_mode, this is the authoritative maximum execution window after liquidity reservation; the exact payout_due_at_ms stays internal.",
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        payout_schedule: {
+          type: "array",
+          minItems: 1,
+          maxItems: 1,
+          items: {
+            $ref: "#/$defs/spendingPolicyDestination"
+          }
+        },
+        fragment_count: {
+          type: "integer",
+          minimum: 1,
+          maximum: 1
+        },
+        payout_mode: {
+          enum: ["instant", "scheduled"]
+        },
+        matching_mode: {
+          const: "exact_1_to_1"
+        },
+        fragmentation_allowed: {
+          const: "payout_side_only"
+        },
+        min_fee_bps: {
+          type: "integer",
+          minimum: 0,
+          maximum: 1e4
+        },
+        fee_bps: {
+          type: "integer",
+          minimum: 0,
+          maximum: 1e4
+        },
+        fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        net_payout_lamports: {
+          $ref: "#/$defs/safeUInt"
+        }
+      }
+    },
+    swapRequestResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["swap_id", "accepted", "policy_snapshot"],
+      properties: {
+        swap_id: {
+          $ref: "#/$defs/string"
+        },
+        accepted: {
+          const: true
+        },
+        policy_snapshot: {
+          $ref: "#/$defs/spendingPolicySnapshot"
+        }
+      }
+    },
+    dkgInitResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["ready"],
+      properties: {
+        ready: {
+          const: true
+        }
+      }
+    },
+    dkgRoundPackage: {
+      type: "object",
+      additionalProperties: false,
+      required: ["package"],
+      properties: {
+        package: {
+          $ref: "#/$defs/base64urlBytes"
+        }
+      }
+    },
+    dkgRound1Response: {
+      type: "object",
+      additionalProperties: false,
+      required: ["package", "round2_for_alice"],
+      properties: {
+        package: {
+          $ref: "#/$defs/base64urlBytes"
+        },
+        round2_for_alice: {
+          $ref: "#/$defs/base64urlBytes"
+        }
+      }
+    },
+    dkgComplete: {
+      type: "object",
+      additionalProperties: false,
+      required: ["joint_pubkey", "deposit_expires_at_ms"],
+      properties: {
+        joint_pubkey: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        deposit_expires_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        }
+      }
+    },
+    delegateShare: {
+      type: "object",
+      additionalProperties: false,
+      required: ["share", "recovery_commitment"],
+      properties: {
+        share: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        recovery_commitment: {
+          $ref: "#/$defs/base64url32Bytes"
+        }
+      }
+    },
+    delegateShareResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["delegated_at_ms"],
+      properties: {
+        delegated_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    delegateAck: {
+      type: "object",
+      additionalProperties: false,
+      required: ["delegated_at_ms", "spending_policy"],
+      properties: {
+        delegated_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        spending_policy: {
+          $ref: "#/$defs/spendingPolicySnapshot"
+        }
+      }
+    },
+    depositConfirmed: {
+      type: "object",
+      additionalProperties: false,
+      required: ["tx_signature", "amount_lamports", "observed_at_ms"],
+      properties: {
+        tx_signature: {
+          $ref: "#/$defs/string"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        observed_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        origin_address: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    plannedFragment: {
+      type: "object",
+      additionalProperties: false,
+      required: ["index", "amount_lamports", "scheduled_at_ms", "destination_address"],
+      properties: {
+        index: {
+          $ref: "#/$defs/u32"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        scheduled_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        destination_address: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    executedFragment: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "index",
+        "amount_lamports",
+        "destination_address",
+        "tx_signature",
+        "executed_at_ms",
+        "final"
+      ],
+      properties: {
+        index: {
+          $ref: "#/$defs/u32"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        destination_address: {
+          $ref: "#/$defs/string"
+        },
+        tx_signature: {
+          $ref: "#/$defs/string"
+        },
+        executed_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        final: {
+          type: "boolean"
+        }
+      }
+    },
+    payoutSchedule: {
+      type: "object",
+      additionalProperties: false,
+      required: ["mode", "fragments"],
+      properties: {
+        mode: {
+          enum: ["instant", "scheduled"]
+        },
+        fragments: {
+          type: "array",
+          maxItems: 64,
+          items: {
+            $ref: "#/$defs/plannedFragment"
+          }
+        }
+      }
+    },
+    normalUserContractStatus: {
+      enum: ["deposit", "activating", "active", "settling", "completed", "refunded", "expired"]
+    },
+    normalUserSettlementPhase: {
+      enum: [
+        "awaiting_deposit",
+        "activating",
+        "waiting_for_liquidity",
+        "matched_scheduled",
+        "locked_pending_payout",
+        "submitted",
+        "confirming",
+        "completed",
+        "refund_pending",
+        "refunded",
+        "expired"
+      ]
+    },
+    normalUserRefundability: {
+      enum: ["available_now", "request_pending", "blocked_by_lock", "stale", "unavailable"]
+    },
+    sourceLiquidityUse: {
+      enum: [
+        "not_materialized",
+        "available",
+        "locked_for_payout",
+        "pending_finality",
+        "spent",
+        "released"
+      ]
+    },
+    syncRetryInstruction: {
+      type: "object",
+      additionalProperties: false,
+      required: ["should_retry", "poll_after_ms"],
+      properties: {
+        should_retry: {
+          type: "boolean"
+        },
+        poll_after_ms: {
+          anyOf: [
+            {
+              type: "null"
+            },
+            {
+              $ref: "#/$defs/safeUInt"
+            }
+          ]
+        }
+      }
+    },
+    payoutWindowSyncSnapshot: {
+      type: "object",
+      additionalProperties: false,
+      required: ["starts_at_ms", "deadline_ms"],
+      properties: {
+        starts_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        },
+        deadline_ms: {
+          anyOf: [
+            {
+              type: "null"
+            },
+            {
+              $ref: "#/$defs/safeUInt"
+            }
+          ]
+        }
+      }
+    },
+    normalUserContractSyncSnapshot: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "contract_id",
+        "status",
+        "settlement_phase",
+        "refundability",
+        "source_liquidity_use",
+        "destination_wallet",
+        "deposit_amount_lamports",
+        "deposit_expires_at_ms",
+        "payout_window",
+        "settlement_tx_hashes",
+        "settled_amount_lamports",
+        "protocol_fee_lamports",
+        "network_fee_lost_lamports",
+        "withdrawal_requested_lamports",
+        "withdrawal_landed_lamports",
+        "withdrawal_landed_fee_lamports",
+        "withdrawal_canceled_lamports",
+        "withdrawal_network_fee_loss_lamports",
+        "withdrawal_tx_hashes",
+        "retry",
+        "state_version",
+        "updated_at_ms"
+      ],
+      properties: {
+        contract_id: {
+          $ref: "#/$defs/string"
+        },
+        status: {
+          $ref: "#/$defs/normalUserContractStatus"
+        },
+        settlement_phase: {
+          $ref: "#/$defs/normalUserSettlementPhase"
+        },
+        refundability: {
+          $ref: "#/$defs/normalUserRefundability"
+        },
+        source_liquidity_use: {
+          $ref: "#/$defs/sourceLiquidityUse"
+        },
+        destination_wallet: {
+          anyOf: [
+            {
+              type: "null"
+            },
+            {
+              $ref: "#/$defs/string"
+            }
+          ]
+        },
+        deposit_amount_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        deposit_expires_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        },
+        payout_window: {
+          $ref: "#/$defs/payoutWindowSyncSnapshot"
+        },
+        settlement_tx_hashes: {
+          type: "array",
+          maxItems: 64,
+          items: {
+            $ref: "#/$defs/string"
+          }
+        },
+        settled_amount_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        protocol_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        network_fee_lost_lamports: {
+          type: "array",
+          maxItems: 64,
+          items: {
+            $ref: "#/$defs/safeUInt"
+          }
+        },
+        withdrawal_requested_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_landed_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_landed_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_canceled_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_network_fee_loss_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_tx_hashes: {
+          type: "array",
+          maxItems: 64,
+          items: {
+            $ref: "#/$defs/string"
+          }
+        },
+        retry: {
+          $ref: "#/$defs/syncRetryInstruction"
+        },
+        state_version: {
+          $ref: "#/$defs/safeUInt"
+        },
+        updated_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        }
+      }
+    },
+    normalUserActorSyncSnapshot: {
+      type: "object",
+      additionalProperties: false,
+      required: ["actor", "snapshot"],
+      properties: {
+        actor: {
+          const: "normal_user"
+        },
+        snapshot: {
+          $ref: "#/$defs/normalUserContractSyncSnapshot"
+        }
+      }
+    },
+    syncResponse: {
+      oneOf: [
+        {
+          $ref: "#/$defs/syncUserResponse"
+        },
+        {
+          $ref: "#/$defs/lpPositionResponse"
+        }
+      ]
+    },
+    syncRequiredContractSubject: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "id"],
+      properties: {
+        kind: {
+          const: "contract"
+        },
+        id: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    syncRequiredLpPositionSubject: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "id"],
+      properties: {
+        kind: {
+          const: "lp_position"
+        },
+        id: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    syncRequiredContract: {
+      type: "object",
+      additionalProperties: false,
+      required: ["subject", "event_kind", "state_version", "created_at_ms", "sync_required"],
+      properties: {
+        subject: {
+          $ref: "#/$defs/syncRequiredContractSubject"
+        },
+        event_kind: {
+          enum: [
+            "contract_requested",
+            "request_expired",
+            "contract_activated",
+            "match_requested",
+            "reserved",
+            "settlement_pending",
+            "partially_fulfilled",
+            "fulfilled",
+            "refund_requested",
+            "refunded",
+            "source_liquidity_updated",
+            "withdrawal_requested",
+            "withdrawal_finalized"
+          ]
+        },
+        state_version: {
+          $ref: "#/$defs/safeUInt"
+        },
+        created_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        },
+        sync_required: {
+          const: true
+        }
+      }
+    },
+    syncRequiredLpPosition: {
+      type: "object",
+      additionalProperties: false,
+      required: ["subject", "event_kind", "state_version", "created_at_ms", "sync_required"],
+      properties: {
+        subject: {
+          $ref: "#/$defs/syncRequiredLpPositionSubject"
+        },
+        event_kind: {
+          enum: [
+            "match_requested",
+            "reserved",
+            "withdrawal_requested",
+            "withdrawal_finalized",
+            "reimbursement_finalized"
+          ]
+        },
+        state_version: {
+          $ref: "#/$defs/safeUInt"
+        },
+        created_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        },
+        sync_required: {
+          const: true
+        }
+      }
+    },
+    syncRequired: {
+      oneOf: [
+        {
+          $ref: "#/$defs/syncRequiredContract"
+        },
+        {
+          $ref: "#/$defs/syncRequiredLpPosition"
+        }
+      ]
+    },
+    syncUserResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["state", "fragments_executed"],
+      properties: {
+        state: {
+          enum: [
+            "new",
+            "awaiting_dkg",
+            "awaiting_deposit",
+            "awaiting_delegation",
+            "ready_for_settlement",
+            "settling",
+            "completed",
+            "refunded",
+            "failed"
+          ]
+        },
+        fragments_executed: {
+          type: "array",
+          maxItems: 64,
+          items: {
+            $ref: "#/$defs/executedFragment"
+          }
+        },
+        withdraw_execution: {
+          $ref: "#/$defs/withdrawExecuted"
+        },
+        actor_sync: {
+          $ref: "#/$defs/normalUserActorSyncSnapshot"
+        }
+      }
+    },
+    lpPositionResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "position"
+        },
+        value: {
+          $ref: "#/$defs/lpPositionView"
+        }
+      }
+    },
+    withdrawRequestRequest: {
+      oneOf: [
+        {
+          $ref: "#/$defs/withdrawRequest"
+        },
+        {
+          $ref: "#/$defs/withdrawRequestProtocolRequest"
+        },
+        {
+          $ref: "#/$defs/withdrawRequestLpRequest"
+        }
+      ]
+    },
+    withdrawRequestLpRequest: {
+      $comment: "The LP arm of the WithdrawRequest verb: an LP-signed withdraw_request command with an explicit principal/fee bucket claim.",
+      type: "object",
+      additionalProperties: false,
+      required: ["actor", "command", "signature"],
+      properties: {
+        actor: {
+          const: "lp"
+        },
+        command: {
+          $ref: "#/$defs/lpCommand"
+        },
+        signature: {
+          $ref: "#/$defs/base64url64Bytes"
+        }
+      },
+      allOf: [
+        {
+          type: "object",
+          properties: {
+            command: {
+              type: "object",
+              properties: {
+                action: {
+                  const: "withdraw_request"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    withdrawRequestProtocolRequest: {
+      $comment: "The protocol arm of the WithdrawRequest verb is a schema-valid V0 no-op. The coordinator returns `Protocol withdraw no-op yet` and creates no sealed executable work.",
+      type: "object",
+      additionalProperties: false,
+      required: ["actor"],
+      properties: {
+        actor: {
+          const: "protocol"
+        }
+      }
+    },
+    withdrawRequest: {
+      $comment: "The user arm of the WithdrawRequest verb: a Recovery Code withdrawal on the Noise session.",
+      type: "object",
+      additionalProperties: false,
+      required: ["recovery_code"],
+      properties: {
+        recovery_code: {
+          $ref: "#/$defs/base64url32Bytes"
+        }
+      }
+    },
+    withdrawExecuted: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "tx_signature",
+        "amount_lamports",
+        "withdrawn_at_ms",
+        "trigger",
+        "destination_address"
+      ],
+      properties: {
+        tx_signature: {
+          $ref: "#/$defs/string"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        withdrawn_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        trigger: {
+          enum: ["user_request", "auto_deadline"]
+        },
+        destination_address: {
+          $ref: "#/$defs/string"
+        }
+      }
+    },
+    withdrawAccepted: {
+      type: "object",
+      additionalProperties: false,
+      required: ["status", "amount_lamports", "destination_address", "accepted_at_ms"],
+      properties: {
+        status: {
+          enum: ["accepted"]
+        },
+        amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        destination_address: {
+          $ref: "#/$defs/string"
+        },
+        accepted_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    errorPayload: {
+      type: "object",
+      additionalProperties: false,
+      required: ["code", "message"],
+      properties: {
+        code: {
+          enum: [
+            "ERR_INVALID_PAYLOAD",
+            "ERR_UNEXPECTED_TYPE",
+            "ERR_UNKNOWN_SWAP",
+            "ERR_POLICY_VIOLATION",
+            "ERR_INVALID_RECOVERY_CODE",
+            "ERR_SWAP_NOT_REFUNDABLE",
+            "ERR_DKG_FAILURE",
+            "ERR_INTERNAL",
+            "ERR_INVALID_DEPOSIT",
+            "ERR_SETTLEMENT_FAILED"
+          ]
+        },
+        message: {
+          $ref: "#/$defs/string"
+        },
+        failed_req_id: {
+          $ref: "#/$defs/u32"
+        }
+      }
+    },
+    base64url64Bytes: {
+      type: "string",
+      minLength: 86,
+      maxLength: 86,
+      pattern: "^[A-Za-z0-9_-]{86}$"
+    },
+    base64urlMax16384Bytes: {
+      type: "string",
+      minLength: 2,
+      maxLength: 21846,
+      pattern: "^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}|[A-Za-z0-9_-]{3})?$"
+    },
+    lpId: {
+      type: "string",
+      minLength: 3,
+      maxLength: 96,
+      pattern: "^[A-Za-z0-9_-]+$"
+    },
+    lpRedemptionId: {
+      type: "string",
+      minLength: 1,
+      maxLength: 160,
+      pattern: "^[A-Za-z0-9_:-]+$"
+    },
+    lpAddress: {
+      type: "string",
+      minLength: 1,
+      maxLength: 128
+    },
+    lpSessionId: {
+      type: "string",
+      minLength: 1,
+      maxLength: 128
+    },
+    lpTxSignature: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256
+    },
+    lpSignedCommand: {
+      type: "object",
+      additionalProperties: false,
+      required: ["command", "signature"],
+      properties: {
+        command: {
+          $ref: "#/$defs/lpCommand"
+        },
+        signature: {
+          $ref: "#/$defs/base64url64Bytes"
+        }
+      }
+    },
+    lpCommand: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "lp_position_id",
+        "action",
+        "nonce",
+        "expires_at_ms",
+        "coordinator_attestation_hash",
+        "payload"
+      ],
+      properties: {
+        lp_position_id: {
+          $ref: "#/$defs/lpId"
+        },
+        action: {
+          enum: [
+            "position_open",
+            "position_get",
+            "dkg_init",
+            "dkg_round1",
+            "dkg_round2",
+            "dkg_finalize",
+            "refill",
+            "funding_plan",
+            "funding_confirmation",
+            "make_available",
+            "reconcile_funding",
+            "prepare_top_up",
+            "top_up_status",
+            "withdraw_request"
+          ]
+        },
+        nonce: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        expires_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        coordinator_attestation_hash: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        payload: {
+          $ref: "#/$defs/lpCommandBody"
+        }
+      },
+      allOf: [
+        {
+          oneOf: [
+            {
+              properties: {
+                action: {
+                  const: "position_open"
+                },
+                payload: {
+                  $ref: "#/$defs/lpPositionOpenCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "position_get"
+                },
+                payload: {
+                  $ref: "#/$defs/lpPositionGetCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "dkg_init"
+                },
+                payload: {
+                  $ref: "#/$defs/lpDkgInitCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "dkg_round1"
+                },
+                payload: {
+                  $ref: "#/$defs/lpDkgRound1Case"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "dkg_round2"
+                },
+                payload: {
+                  $ref: "#/$defs/lpDkgRound2Case"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "dkg_finalize"
+                },
+                payload: {
+                  $ref: "#/$defs/lpDkgFinalizeCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "refill"
+                },
+                payload: {
+                  $ref: "#/$defs/lpRefillCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "funding_plan"
+                },
+                payload: {
+                  $ref: "#/$defs/lpFundingPlanCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "funding_confirmation"
+                },
+                payload: {
+                  $ref: "#/$defs/lpFundingConfirmationCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "make_available"
+                },
+                payload: {
+                  $ref: "#/$defs/lpMakeAvailableCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "reconcile_funding"
+                },
+                payload: {
+                  $ref: "#/$defs/lpReconcileFundingCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "prepare_top_up"
+                },
+                payload: {
+                  $ref: "#/$defs/lpPrepareTopUpCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "top_up_status"
+                },
+                payload: {
+                  $ref: "#/$defs/lpTopUpStatusCase"
+                }
+              }
+            },
+            {
+              properties: {
+                action: {
+                  const: "withdraw_request"
+                },
+                payload: {
+                  $ref: "#/$defs/lpWithdrawalRequestCase"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    lpCommandBody: {
+      oneOf: [
+        {
+          $ref: "#/$defs/lpPositionOpenCase"
+        },
+        {
+          $ref: "#/$defs/lpPositionGetCase"
+        },
+        {
+          $ref: "#/$defs/lpDkgInitCase"
+        },
+        {
+          $ref: "#/$defs/lpDkgRound1Case"
+        },
+        {
+          $ref: "#/$defs/lpDkgRound2Case"
+        },
+        {
+          $ref: "#/$defs/lpDkgFinalizeCase"
+        },
+        {
+          $ref: "#/$defs/lpRefillCase"
+        },
+        {
+          $ref: "#/$defs/lpFundingPlanCase"
+        },
+        {
+          $ref: "#/$defs/lpFundingConfirmationCase"
+        },
+        {
+          $ref: "#/$defs/lpMakeAvailableCase"
+        },
+        {
+          $ref: "#/$defs/lpReconcileFundingCase"
+        },
+        {
+          $ref: "#/$defs/lpPrepareTopUpCase"
+        },
+        {
+          $ref: "#/$defs/lpTopUpStatusCase"
+        },
+        {
+          $ref: "#/$defs/lpWithdrawalRequestCase"
+        }
+      ]
+    },
+    lpPositionOpenCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "positionOpen"
+        },
+        value: {
+          $ref: "#/$defs/lpPositionOpen"
+        }
+      }
+    },
+    lpPositionGetCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "positionGet"
+        },
+        value: {
+          $ref: "#/$defs/lpPositionGet"
+        }
+      }
+    },
+    lpDkgInitCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "dkgInit"
+        },
+        value: {
+          $ref: "#/$defs/lpDkgInit"
+        }
+      }
+    },
+    lpDkgRound1Case: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "dkgRound1"
+        },
+        value: {
+          $ref: "#/$defs/lpDkgRound1"
+        }
+      }
+    },
+    lpDkgRound2Case: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "dkgRound2"
+        },
+        value: {
+          $ref: "#/$defs/lpDkgRound2"
+        }
+      }
+    },
+    lpDkgFinalizeCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "dkgFinalize"
+        },
+        value: {
+          $ref: "#/$defs/lpDkgFinalize"
+        }
+      }
+    },
+    lpRefillCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "refill"
+        },
+        value: {
+          $ref: "#/$defs/lpRefill"
+        }
+      }
+    },
+    lpFundingPlanCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "fundingPlan"
+        },
+        value: {
+          $ref: "#/$defs/lpFundingPlan"
+        }
+      }
+    },
+    lpFundingConfirmationCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "fundingConfirmation"
+        },
+        value: {
+          $ref: "#/$defs/lpFundingConfirmation"
+        }
+      }
+    },
+    lpMakeAvailableCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "makeAvailable"
+        },
+        value: {
+          $ref: "#/$defs/lpMakeAvailable"
+        }
+      }
+    },
+    lpReconcileFundingCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "reconcileFunding"
+        },
+        value: {
+          $ref: "#/$defs/emptyObject"
+        }
+      }
+    },
+    lpPrepareTopUpCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "prepareTopUp"
+        },
+        value: {
+          $ref: "#/$defs/emptyObject"
+        }
+      }
+    },
+    lpTopUpStatusCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "topUpStatus"
+        },
+        value: {
+          $ref: "#/$defs/lpTopUpStatus"
+        }
+      }
+    },
+    lpTopUpStatus: {
+      type: "object",
+      additionalProperties: false,
+      required: ["top_up_id"],
+      properties: {
+        top_up_id: {
+          $ref: "#/$defs/lpId"
+        }
+      }
+    },
+    lpPositionGet: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        redemption_history_cursor: {
+          $ref: "#/$defs/lpRedemptionId"
+        }
+      }
+    },
+    lpPositionOpen: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "auth_public_key",
+        "refill_public_key",
+        "redemption_commitment",
+        "committed_lamports",
+        "shard_count",
+        "shard_amount_lamports",
+        "refill_threshold",
+        "addresses",
+        "created_at_ms"
+      ],
+      properties: {
+        auth_public_key: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        refill_public_key: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        redemption_commitment: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        committed_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        shard_count: {
+          type: "integer",
+          minimum: 1,
+          maximum: 300
+        },
+        shard_amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        refill_threshold: {
+          type: "integer",
+          minimum: 0,
+          maximum: 300
+        },
+        addresses: {
+          type: "array",
+          maxItems: 300,
+          items: {
+            $ref: "#/$defs/lpAddress"
+          }
+        },
+        created_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    lpDkgInit: {
+      type: "object",
+      additionalProperties: false,
+      required: ["index"],
+      properties: {
+        index: {
+          $ref: "#/$defs/lpShardIndex"
+        }
+      }
+    },
+    lpDkgRound1: {
+      type: "object",
+      additionalProperties: false,
+      required: ["session_id", "package"],
+      properties: {
+        session_id: {
+          $ref: "#/$defs/lpSessionId"
+        },
+        package: {
+          $ref: "#/$defs/base64urlMax16384Bytes"
+        }
+      }
+    },
+    lpDkgRound2: {
+      type: "object",
+      additionalProperties: false,
+      required: ["session_id", "package", "delegated_share"],
+      properties: {
+        session_id: {
+          $ref: "#/$defs/lpSessionId"
+        },
+        package: {
+          $ref: "#/$defs/base64urlMax16384Bytes"
+        },
+        delegated_share: {
+          $ref: "#/$defs/base64urlMax16384Bytes"
+        }
+      }
+    },
+    lpDkgFinalize: {
+      type: "object",
+      additionalProperties: false,
+      required: ["start_index", "addresses", "finalized_at_ms"],
+      properties: {
+        start_index: {
+          $ref: "#/$defs/lpShardIndex"
+        },
+        addresses: {
+          type: "array",
+          minItems: 1,
+          maxItems: 300,
+          items: {
+            $ref: "#/$defs/lpAddress"
+          }
+        },
+        finalized_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    lpRefill: {
+      type: "object",
+      additionalProperties: false,
+      required: ["shard_count", "shard_amount_lamports", "addresses", "authorized_at_ms"],
+      properties: {
+        shard_count: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50
+        },
+        shard_amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        addresses: {
+          type: "array",
+          maxItems: 50,
+          items: {
+            $ref: "#/$defs/lpAddress"
+          }
+        },
+        authorized_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    lpFundingPlan: {
+      type: "object",
+      additionalProperties: false,
+      required: ["shard_count", "planned_at_ms"],
+      properties: {
+        shard_count: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50
+        },
+        planned_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    lpFundingConfirmation: {
+      type: "object",
+      additionalProperties: false,
+      required: ["shard_id", "amount_lamports", "funding_tx_signature"],
+      properties: {
+        shard_id: {
+          $ref: "#/$defs/lpShardId"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        funding_tx_signature: {
+          $ref: "#/$defs/lpTxSignature"
+        }
+      }
+    },
+    lpMakeAvailable: {
+      type: "object",
+      additionalProperties: false,
+      required: ["shard_id"],
+      properties: {
+        shard_id: {
+          $ref: "#/$defs/lpShardId"
+        }
+      }
+    },
+    lpCommandResponse: {
+      $comment: "Union of all LP-signed command responses, regardless of carrier envelope. Envelope variants below narrow this: LpCommand gets lifecycle-only responses, WithdrawRequest gets withdrawalExecution.",
+      oneOf: [
+        {
+          $ref: "#/$defs/lpCommandLifecycleResponse"
+        },
+        {
+          $ref: "#/$defs/lpWithdrawalExecutionResponse"
+        }
+      ]
+    },
+    lpCommandLifecycleResponse: {
+      oneOf: [
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "position"
+            },
+            value: {
+              $ref: "#/$defs/lpPositionView"
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "dkgInit"
+            },
+            value: {
+              $ref: "#/$defs/lpDkgInitResponse"
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "dkgRound1"
+            },
+            value: {
+              $ref: "#/$defs/lpDkgRound1Response"
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "dkgRound2"
+            },
+            value: {
+              $ref: "#/$defs/lpDkgRound2Response"
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "shards"
+            },
+            value: {
+              type: "array",
+              maxItems: 300,
+              items: {
+                $ref: "#/$defs/lpShardView"
+              }
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "shard"
+            },
+            value: {
+              $ref: "#/$defs/lpShardView"
+            }
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: ["case", "value"],
+          properties: {
+            case: {
+              const: "topUpRequest"
+            },
+            value: {
+              $ref: "#/$defs/lpTopUpRequest"
+            }
+          }
+        }
+      ]
+    },
+    lpTopUpRequest: {
+      type: "object",
+      additionalProperties: false,
+      required: ["top_up_id", "lp_position_id", "deposit_address", "expires_at_ms", "status"],
+      properties: {
+        top_up_id: {
+          $ref: "#/$defs/lpId"
+        },
+        lp_position_id: {
+          $ref: "#/$defs/lpId"
+        },
+        deposit_address: {
+          $ref: "#/$defs/lpAddress"
+        },
+        expires_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        status: {
+          enum: ["watching", "funded", "expired"]
+        }
+      }
+    },
+    lpWithdrawalExecutionResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "withdrawalExecution"
+        },
+        value: {
+          $ref: "#/$defs/lpWithdrawalExecutionView"
+        }
+      }
+    },
+    lpDkgInitResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["session_id"],
+      properties: {
+        session_id: {
+          $ref: "#/$defs/lpSessionId"
+        }
+      }
+    },
+    lpDkgRound1Response: {
+      type: "object",
+      additionalProperties: false,
+      required: ["package", "round2_for_lp"],
+      properties: {
+        package: {
+          $ref: "#/$defs/base64urlMax16384Bytes"
+        },
+        round2_for_lp: {
+          $ref: "#/$defs/base64urlMax16384Bytes"
+        }
+      }
+    },
+    lpDkgRound2Response: {
+      type: "object",
+      additionalProperties: false,
+      required: ["lp_position_id", "shard_id", "index", "address", "joint_pubkey"],
+      properties: {
+        lp_position_id: {
+          $ref: "#/$defs/lpId"
+        },
+        shard_id: {
+          $ref: "#/$defs/lpShardId"
+        },
+        index: {
+          $ref: "#/$defs/lpShardIndex"
+        },
+        address: {
+          $ref: "#/$defs/lpAddress"
+        },
+        joint_pubkey: {
+          $ref: "#/$defs/base64url32Bytes"
+        }
+      }
+    },
+    lpPositionView: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "lp_position_id",
+        "status",
+        "target_shard_count",
+        "auth_public_key",
+        "refill_public_key",
+        "redemption_commitment",
+        "committed_lamports",
+        "earned_lamports",
+        "refill_threshold",
+        "shards",
+        "created_at_ms"
+      ],
+      properties: {
+        lp_position_id: {
+          $ref: "#/$defs/lpId"
+        },
+        status: {
+          enum: ["dkg_pending", "active", "withdrawing", "closed"]
+        },
+        target_shard_count: {
+          type: "integer",
+          minimum: 0,
+          maximum: 300
+        },
+        auth_public_key: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        refill_public_key: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        redemption_commitment: {
+          $ref: "#/$defs/base64url32Bytes"
+        },
+        committed_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        earned_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        refill_threshold: {
+          type: "integer",
+          minimum: 0,
+          maximum: 300
+        },
+        shards: {
+          type: "array",
+          maxItems: 300,
+          items: {
+            $ref: "#/$defs/lpShardView"
+          }
+        },
+        created_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        actor_sync: {
+          $ref: "#/$defs/lpActorSyncView"
+        }
+      }
+    },
+    lpActorSyncView: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "lp_position_id",
+        "status",
+        "source_liquidity_use",
+        "pending_reservation_count",
+        "reserved_payout_lamports",
+        "estimated_network_fee_lamports",
+        "reimbursement_due_count",
+        "reimbursement_due_source_count",
+        "reimbursement_due_payout_lamports",
+        "reimbursement_due_network_fee_lamports",
+        "withdrawal_requested_lamports",
+        "withdrawal_landed_lamports",
+        "withdrawal_landed_fee_lamports",
+        "withdrawal_canceled_lamports",
+        "withdrawal_network_fee_loss_lamports",
+        "withdrawal_tx_hashes",
+        "state_version",
+        "updated_at_ms"
+      ],
+      dependentRequired: {
+        redeemable_principal_lamports: [
+          "redeemable_fee_lamports",
+          "lifetime_earned_lamports",
+          "redeemable_principal_source_count",
+          "redeemable_fee_source_count"
+        ],
+        redeemable_fee_lamports: [
+          "redeemable_principal_lamports",
+          "lifetime_earned_lamports",
+          "redeemable_principal_source_count",
+          "redeemable_fee_source_count"
+        ],
+        lifetime_earned_lamports: [
+          "redeemable_principal_lamports",
+          "redeemable_fee_lamports",
+          "redeemable_principal_source_count",
+          "redeemable_fee_source_count"
+        ],
+        redeemable_principal_source_count: [
+          "redeemable_principal_lamports",
+          "redeemable_fee_lamports",
+          "lifetime_earned_lamports",
+          "redeemable_fee_source_count"
+        ],
+        redeemable_fee_source_count: [
+          "redeemable_principal_lamports",
+          "redeemable_fee_lamports",
+          "lifetime_earned_lamports",
+          "redeemable_principal_source_count"
+        ]
+      },
+      properties: {
+        lp_position_id: {
+          $ref: "#/$defs/lpId"
+        },
+        status: {
+          enum: ["idle", "settling", "reimbursement_due"]
+        },
+        source_liquidity_use: {
+          $ref: "#/$defs/sourceLiquidityUse"
+        },
+        redeemable_principal_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        redeemable_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        lifetime_earned_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        redeemable_principal_source_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        redeemable_fee_source_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        pending_reservation_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        reserved_payout_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        estimated_network_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        reimbursement_due_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        reimbursement_due_source_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        reimbursement_due_payout_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        reimbursement_due_network_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_requested_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_landed_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_landed_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_canceled_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_network_fee_loss_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        withdrawal_tx_hashes: {
+          type: "array",
+          maxItems: 300,
+          items: {
+            $ref: "#/$defs/lpTxSignature"
+          }
+        },
+        redemption_history: {
+          type: "array",
+          maxItems: 32,
+          items: {
+            $ref: "#/$defs/lpRedemptionHistory"
+          }
+        },
+        redemption_history_has_more: {
+          type: "boolean"
+        },
+        redemption_history_next_cursor: {
+          $ref: "#/$defs/lpRedemptionId"
+        },
+        state_version: {
+          $ref: "#/$defs/safeUInt"
+        },
+        updated_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        }
+      }
+    },
+    lpRedemptionHistory: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "redemption_id",
+        "state",
+        "accepted_lamports",
+        "accepted_deposit_principal_lamports",
+        "accepted_earned_fee_lamports",
+        "landed_lamports",
+        "landed_deposit_principal_lamports",
+        "landed_earned_fee_lamports",
+        "canceled_lamports",
+        "canceled_deposit_principal_lamports",
+        "canceled_earned_fee_lamports",
+        "network_fee_lamports",
+        "network_fee_loss_lamports",
+        "failed_attempts",
+        "destination_addresses",
+        "destination_count",
+        "tx_signatures",
+        "tx_signature_count",
+        "details_truncated",
+        "state_version",
+        "created_at_ms",
+        "updated_at_ms"
+      ],
+      properties: {
+        redemption_id: {
+          $ref: "#/$defs/lpRedemptionId"
+        },
+        state: {
+          enum: ["requested", "match_requested", "reserved", "pending", "confirmed", "rejected"]
+        },
+        accepted_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        accepted_deposit_principal_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        accepted_earned_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        landed_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        landed_deposit_principal_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        landed_earned_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        canceled_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        canceled_deposit_principal_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        canceled_earned_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        network_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        network_fee_loss_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        failed_attempts: {
+          $ref: "#/$defs/safeUInt"
+        },
+        destination_addresses: {
+          type: "array",
+          minItems: 1,
+          maxItems: 1e3,
+          items: {
+            $ref: "#/$defs/lpAddress"
+          }
+        },
+        destination_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        tx_signatures: {
+          type: "array",
+          maxItems: 32,
+          items: {
+            $ref: "#/$defs/lpTxSignature"
+          }
+        },
+        tx_signature_count: {
+          $ref: "#/$defs/safeUInt"
+        },
+        details_truncated: {
+          type: "boolean"
+        },
+        state_version: {
+          $ref: "#/$defs/safeUInt"
+        },
+        created_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        },
+        updated_at_ms: {
+          $ref: "#/$defs/safeUInt"
+        }
+      }
+    },
+    lpShardView: {
+      type: "object",
+      additionalProperties: false,
+      required: ["lp_position_id", "shard_id", "index", "address", "amount_lamports", "status"],
+      properties: {
+        lp_position_id: {
+          $ref: "#/$defs/lpId"
+        },
+        shard_id: {
+          $ref: "#/$defs/lpShardId"
+        },
+        index: {
+          $ref: "#/$defs/lpShardIndex"
+        },
+        address: {
+          $ref: "#/$defs/lpAddress"
+        },
+        amount_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        required_lamports: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        status: {
+          enum: [
+            "pregenerated",
+            "funding_queued",
+            "funded",
+            "cooling",
+            "available",
+            "reserved",
+            "retired",
+            "redeemed"
+          ]
+        },
+        funding_tx_signature: {
+          $ref: "#/$defs/lpTxSignature"
+        },
+        cooling_until_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        },
+        payout_tx_signature: {
+          $ref: "#/$defs/lpTxSignature"
+        }
+      }
+    },
+    lpShardId: {
+      type: "string",
+      minLength: 1,
+      maxLength: 160
+    },
+    lpWithdrawalRequestCase: {
+      type: "object",
+      additionalProperties: false,
+      required: ["case", "value"],
+      properties: {
+        case: {
+          const: "withdrawRequest"
+        },
+        value: {
+          $ref: "#/$defs/lpWithdrawalRequest"
+        }
+      }
+    },
+    lpWithdrawalRequest: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "destination_addresses",
+        "deposit_principal_lamports",
+        "earned_fee_lamports",
+        "requested_at_ms"
+      ],
+      properties: {
+        destination_addresses: {
+          type: "array",
+          minItems: 1,
+          maxItems: 1e3,
+          uniqueItems: true,
+          items: {
+            $ref: "#/$defs/lpAddress"
+          }
+        },
+        deposit_principal_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        earned_fee_lamports: {
+          $ref: "#/$defs/safeUInt"
+        },
+        requested_at_ms: {
+          $ref: "#/$defs/positiveSafeUInt"
+        }
+      }
+    },
+    lpWithdrawalExecutionView: {
+      type: "object",
+      additionalProperties: false,
+      required: ["withdrawal_id", "tx_signatures"],
+      properties: {
+        withdrawal_id: {
+          type: "string",
+          minLength: 1,
+          maxLength: 160
+        },
+        tx_signatures: {
+          type: "array",
+          maxItems: 300,
+          items: {
+            $ref: "#/$defs/lpTxSignature"
+          }
+        }
+      }
+    }
+  }
+};
+
+// ../../protocol/src/coordinator/envelope.ts
+var ENVELOPE_VERSION = 2;
+var MAX_FRAME_SIZE = 256 * 1024;
+var COORDINATOR_ENVELOPE_SCHEMA = coordinator_envelope_schema_default;
+var LP_MAX_TARGET_SHARDS = 300;
+var LP_WITHDRAW_REQUEST_PATH = "lp_command.withdrawRequest";
+var binaryFieldNames = new Set(COORDINATOR_BINARY_FIELD_NAMES);
+var ajv = new Ajv2020({
+  allErrors: true,
+  strict: true
+});
+var validateWireEnvelope = ajv.compile(coordinator_envelope_schema_default);
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+function encode(env) {
+  return textEncoder.encode(JSON.stringify(toWireEnvelope(env)));
+}
+function safeEncode(env) {
+  let wire;
+  try {
+    wire = toWireEnvelope(env);
+  } catch (error) {
+    return {
+      ok: false,
+      error: new CoordinatorError(
+        ErrorCode.ERR_INVALID_PAYLOAD,
+        error instanceof Error ? error.message : String(error)
+      )
+    };
+  }
+  if (!validateWireEnvelope(wire)) {
+    return { ok: false, error: schemaError(wire, validateWireEnvelope.errors ?? []) };
+  }
+  const encoded = textEncoder.encode(JSON.stringify(wire));
+  if (encoded.byteLength > MAX_FRAME_SIZE) {
+    return {
+      ok: false,
+      error: new CoordinatorError(
+        ErrorCode.ERR_INVALID_PAYLOAD,
+        `frame too large: ${encoded.byteLength} > ${MAX_FRAME_SIZE}`
+      )
+    };
+  }
+  return { ok: true, value: encoded };
+}
+function encodeValidated(env) {
+  const encoded = safeEncode(env);
+  if (!encoded.ok) {
+    throw encoded.error;
+  }
+  return encoded.value;
+}
+function lpSignedCommandEnvelope(command, signature) {
+  switch (command.action) {
+    case "position_get":
+      return { type: CoordinatorMessageType.Sync, payload: { actor: "lp", command, signature } };
+    case "refill":
+      return { type: CoordinatorMessageType.Refill, payload: { actor: "lp", command, signature } };
+    case "position_open":
+      return {
+        type: CoordinatorMessageType.ContractRequest,
+        payload: { actor: "lp", command, signature }
+      };
+    case "withdraw_request":
+      return {
+        type: CoordinatorMessageType.WithdrawRequest,
+        payload: { actor: "lp", command, signature }
+      };
+    default:
+      return { type: CoordinatorMessageType.LpCommand, payload: { command, signature } };
+  }
+}
+function encodeLpCommandForSigning(command) {
+  validateLpCommandPreSchemaSemanticsForSigning(command);
+  const { type, payload } = lpSignedCommandEnvelope(command, new Uint8Array(64));
+  const probe = toWireEnvelope({
+    version: ENVELOPE_VERSION,
+    kind: EnvelopeKind.REQUEST,
+    type,
+    swap_id: null,
+    req_id: 0,
+    timestamp_ms: 0,
+    payload
+  });
+  if (!validateWireEnvelope(probe)) {
+    throw schemaError(probe, validateWireEnvelope.errors ?? []);
+  }
+  validateLpCommandSemanticsForSigning(command);
+  return textEncoder.encode(canonicalJsonStringify(toWireValue(command)));
+}
+function validateLpCommandPreSchemaSemanticsForSigning(command) {
+  if (command.payload.case !== "withdrawRequest") return;
+  const value = command.payload.value;
+  const destinationAddresses = value.destination_addresses;
+  if (!Array.isArray(destinationAddresses)) return;
+  validateUniqueLpAddresses(
+    LP_WITHDRAW_REQUEST_PATH,
+    destinationAddresses.filter((address) => typeof address === "string")
+  );
+}
+function validateLpCommandSemanticsForSigning(command) {
+  switch (command.payload.case) {
+    case "positionOpen": {
+      const { addresses, refill_threshold, shard_count } = command.payload.value;
+      if (refill_threshold > shard_count) {
+        throw new CoordinatorError(
+          ErrorCode.ERR_INVALID_PAYLOAD,
+          `lp_command.positionOpen.refill_threshold (${refill_threshold}) must be <= shard_count (${shard_count})`
+        );
+      }
+      validateOptionalLpAddressCount("lp_command.positionOpen", addresses, shard_count);
+      return;
+    }
+    case "refill": {
+      const { addresses, shard_count } = command.payload.value;
+      validateOptionalLpAddressCount("lp_command.refill", addresses, shard_count);
+      return;
+    }
+    case "dkgFinalize": {
+      const { addresses, start_index } = command.payload.value;
+      validateLpDkgFinalizeRange("lp_command.dkgFinalize", start_index, addresses.length);
+      return;
+    }
+    case "withdrawRequest": {
+      const { deposit_principal_lamports, earned_fee_lamports, destination_addresses } = command.payload.value;
+      const bucketTotal = deposit_principal_lamports + earned_fee_lamports;
+      if (!Number.isSafeInteger(bucketTotal) || bucketTotal <= 0) {
+        throw new CoordinatorError(
+          ErrorCode.ERR_INVALID_PAYLOAD,
+          `${LP_WITHDRAW_REQUEST_PATH} bucket claim must be positive`
+        );
+      }
+      validateUniqueLpAddresses(LP_WITHDRAW_REQUEST_PATH, destination_addresses);
+      return;
+    }
+    default:
+      return;
+  }
+}
+function validateOptionalLpAddressCount(path, addresses, shardCount) {
+  if (addresses.length > 0 && addresses.length !== shardCount) {
+    throw new CoordinatorError(
+      ErrorCode.ERR_INVALID_PAYLOAD,
+      `${path}.addresses length (${addresses.length}) must be 0 or equal shard_count (${shardCount})`
+    );
+  }
+}
+function validateUniqueLpAddresses(path, addresses) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const address of addresses) {
+    if (seen.has(address)) {
+      throw new CoordinatorError(
+        ErrorCode.ERR_INVALID_PAYLOAD,
+        `${path} duplicate destination address: ${address}`
+      );
+    }
+    seen.add(address);
+  }
+}
+function validateLpDkgFinalizeRange(path, startIndex, addressCount) {
+  if (addressCount === 0) return;
+  const lastIndex = startIndex + addressCount - 1;
+  if (lastIndex >= LP_MAX_TARGET_SHARDS) {
+    throw new CoordinatorError(
+      ErrorCode.ERR_INVALID_PAYLOAD,
+      `${path}.addresses end index (${lastIndex}) must be <= ${LP_MAX_TARGET_SHARDS - 1}`
+    );
+  }
+}
+function decode(raw) {
+  if (raw.byteLength === 0) {
+    return {
+      ok: false,
+      error: new CoordinatorError(ErrorCode.ERR_INVALID_PAYLOAD, "empty frame")
+    };
+  }
+  if (raw.byteLength > MAX_FRAME_SIZE) {
+    return {
+      ok: false,
+      error: new CoordinatorError(
+        ErrorCode.ERR_INVALID_PAYLOAD,
+        `frame too large: ${raw.byteLength} > ${MAX_FRAME_SIZE}`
+      )
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(textDecoder.decode(raw));
+  } catch (error) {
+    return {
+      ok: false,
+      error: new CoordinatorError(
+        ErrorCode.ERR_INVALID_PAYLOAD,
+        `json decode failed: ${error instanceof Error ? error.message : String(error)}`
+      )
+    };
+  }
+  if (!validateWireEnvelope(parsed)) {
+    return { ok: false, error: schemaError(parsed, validateWireEnvelope.errors ?? []) };
+  }
+  try {
+    return { ok: true, value: fromWireEnvelope(parsed) };
+  } catch (error) {
+    if (error instanceof CoordinatorError) {
+      return { ok: false, error };
+    }
+    return {
+      ok: false,
+      error: new CoordinatorError(
+        ErrorCode.ERR_INVALID_PAYLOAD,
+        error instanceof Error ? error.message : String(error)
+      )
+    };
+  }
+}
+function toWireEnvelope(env) {
+  return stripUndefined({
+    version: env.version,
+    kind: env.kind,
+    type: env.type,
+    swap_id: env.swap_id,
+    req_id: env.req_id,
+    timestamp_ms: env.timestamp_ms,
+    payload: toWireValue(env.payload)
+  });
+}
+function fromWireEnvelope(value) {
+  if (!isRecord2(value)) {
+    throw new CoordinatorError(ErrorCode.ERR_INVALID_PAYLOAD, "envelope must be an object");
+  }
+  const kind = value.kind;
+  const type = value.type;
+  const swapId = value.swap_id;
+  const payload = fromWireValue(value.payload);
+  if (kind === EnvelopeKind.RESPONSE && type === CoordinatorMessageType.ContractRequest && swapId !== null && isRecord2(payload) && typeof payload.swap_id === "string" && payload.swap_id !== swapId) {
+    throw new CoordinatorError(
+      ErrorCode.ERR_INVALID_PAYLOAD,
+      `ContractRequest response: envelope.swap_id (${swapId}) does not match payload.swap_id (${payload.swap_id})`
+    );
+  }
+  return {
+    version: value.version,
+    kind,
+    type,
+    swap_id: swapId,
+    req_id: value.req_id,
+    timestamp_ms: value.timestamp_ms,
+    payload
+  };
+}
+function toWireValue(value, fieldName) {
+  if (value instanceof Uint8Array) {
+    return bytesToBase64Url(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toWireValue(item));
+  }
+  if (isRecord2(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (item !== void 0) {
+        out[key] = toWireValue(item, key);
+      }
+    }
+    return out;
+  }
+  if (fieldName !== void 0 && binaryFieldNames.has(fieldName) && typeof value !== "string") {
+    return value;
+  }
+  return value;
+}
+function fromWireValue(value, fieldName) {
+  if (typeof value === "string" && fieldName !== void 0 && binaryFieldNames.has(fieldName)) {
+    return base64UrlToBytes(value, fieldName);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => fromWireValue(item));
+  }
+  if (isRecord2(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = fromWireValue(item, key);
+    }
+    return out;
+  }
+  return value;
+}
+function schemaError(value, errors) {
+  const code = kindTypeMismatch(value) ? ErrorCode.ERR_UNEXPECTED_TYPE : ErrorCode.ERR_INVALID_PAYLOAD;
+  const expectedIssue = expectedProtocolIssue(value);
+  const formatted = formatErrors(value, errors);
+  const details = expectedIssue === null || formatted.includes(expectedIssue) ? formatted : `${expectedIssue}; ${formatted}`;
+  return new CoordinatorError(code, `json schema validation failed: ${details}`);
+}
+function kindTypeMismatch(value) {
+  if (!isRecord2(value)) return false;
+  const kind = value.kind;
+  const type = value.type;
+  return isValidEnvelopeKind(kind) && isValidMessageType(type) && !isAllowedKindForType(kind, type);
+}
+function formatErrors(value, errors) {
+  if (errors.length === 0) return "no details";
+  const relevant = relevantErrors(errors);
+  return relevant.slice(0, 8).map((error) => formatError(value, error)).filter(uniqueStrings).join("; ");
+}
+function expectedProtocolIssue(value) {
+  if (!isRecord2(value)) return null;
+  if (!isValidEnvelopeKind(value.kind)) return "kind has an unknown value";
+  if (!isValidMessageType(value.type)) return "type has an unknown value";
+  if (!isAllowedKindForType(value.kind, value.type)) {
+    return `kind ${String(value.kind)} is not allowed for type ${String(value.type)}`;
+  }
+  const payload = value.payload;
+  if (!isRecord2(payload)) return `${payloadPathRoot(value)} must be object`;
+  const required = requiredPayloadFields(value.kind, value.type);
+  const missing = required.filter((field) => !(field in payload));
+  return missing.length > 0 ? missing.map((field) => `${payloadPathRoot(value)}.${field} is required`).join("; ") : null;
+}
+function requiredPayloadFields(kind, type) {
+  const key = `${kind}:${type}`;
+  switch (key) {
+    case "request:ContractRequest":
+      return ["actor", "amount_lamports", "payout_spec", "sync_commitment"];
+    case "response:ContractRequest":
+      return ["swap_id", "accepted", "policy_snapshot"];
+    case "response:DkgInit":
+      return ["ready"];
+    case "request:DkgRound1":
+    case "response:DkgRound2":
+    case "request:DkgRound2":
+      return ["package"];
+    case "response:DkgRound1":
+      return ["package", "round2_for_alice"];
+    case "push:DkgComplete":
+      return ["joint_pubkey", "deposit_expires_at_ms"];
+    case "request:DelegateShare":
+      return ["share", "recovery_commitment"];
+    case "response:DelegateShare":
+      return ["delegated_at_ms"];
+    case "push:DelegateAck":
+      return ["delegated_at_ms", "spending_policy"];
+    case "push:DepositConfirmed":
+      return ["tx_signature", "amount_lamports", "observed_at_ms"];
+    case "request:Sync":
+      return ["actor"];
+    case "response:Sync":
+      return ["state", "fragments_executed"];
+    case "push:SyncRequired":
+      return ["subject", "event_kind", "state_version", "created_at_ms", "sync_required"];
+    case "request:Refill":
+      return ["actor", "command", "signature"];
+    case "response:Refill":
+      return ["case", "value"];
+    case "push:PayoutExecuted":
+      return [
+        "index",
+        "amount_lamports",
+        "destination_address",
+        "tx_signature",
+        "executed_at_ms",
+        "final"
+      ];
+    case "request:WithdrawRequest":
+      return ["recovery_code", "actor", "command", "signature"];
+    case "response:WithdrawRequest":
+      return ["case", "value"];
+    case "request:LpCommand":
+      return ["command", "signature"];
+    case "response:LpCommand":
+      return ["case", "value"];
+    case "response:WithdrawExecuted":
+    case "push:WithdrawExecuted":
+      return [
+        "tx_signature",
+        "amount_lamports",
+        "withdrawn_at_ms",
+        "trigger",
+        "destination_address"
+      ];
+    case "response:WithdrawAccepted":
+      return ["status", "amount_lamports", "destination_address", "accepted_at_ms"];
+    case "error:Error":
+      return ["code", "message"];
+    default:
+      return [];
+  }
+}
+function relevantErrors(errors) {
+  const lpCommandErrors = errors.filter(
+    (error) => error.instancePath.startsWith("/payload/command") || error.instancePath.startsWith("/payload/signature")
+  );
+  const specificLpCommandErrors = lpCommandErrors.filter(
+    (error) => error.keyword !== "const" && error.keyword !== "required"
+  );
+  if (specificLpCommandErrors.length > 0) return specificLpCommandErrors;
+  if (lpCommandErrors.length > 0) return lpCommandErrors;
+  const actorSyncErrors = errors.filter(
+    (error) => error.instancePath.startsWith("/payload/actor_sync")
+  );
+  if (actorSyncErrors.length > 0) return actorSyncErrors;
+  const payloadErrors = errors.filter((error) => error.instancePath.startsWith("/payload"));
+  const requiredPayloadErrors = errors.filter(
+    (error) => error.keyword === "required" && error.instancePath === "/payload"
+  );
+  const topLevelErrors = errors.filter((error) => !error.schemaPath.includes("/oneOf/"));
+  const relevant = [...payloadErrors, ...requiredPayloadErrors, ...topLevelErrors];
+  return relevant.length > 0 ? relevant : errors;
+}
+function formatError(value, error) {
+  const path = pathForError(value, error);
+  switch (error.keyword) {
+    case "required":
+      return `${path} is required`;
+    case "additionalProperties":
+      return `${path} is not allowed`;
+    case "const":
+      return `${path} has the wrong literal value`;
+    case "enum":
+      return `${path} has an unknown value`;
+    case "oneOf":
+    case "anyOf":
+      return `${path} does not match any allowed protocol shape`;
+    case "pattern":
+      return `${path} must use base64url without padding`;
+    case "minLength":
+    case "maxLength":
+    case "minimum":
+    case "maximum":
+    case "type":
+      return `${path} ${error.message ?? "is invalid"}`;
+    default:
+      return `${path} ${error.message ?? error.keyword}`;
+  }
+}
+function pathForError(value, error) {
+  const parts = pointerParts(error.instancePath);
+  if (error.keyword === "required" && typeof error.params.missingProperty === "string") {
+    parts.push(error.params.missingProperty);
+  }
+  if (error.keyword === "additionalProperties" && typeof error.params.additionalProperty === "string") {
+    parts.push(error.params.additionalProperty);
+  }
+  if (parts[0] === "payload") {
+    const payloadRoot = payloadPathRoot(value);
+    const rest = parts.slice(1);
+    return rest.length > 0 ? `${payloadRoot}.${rest.join(".")}` : payloadRoot;
+  }
+  return parts.length > 0 ? parts.join(".") : "envelope";
+}
+function payloadPathRoot(value) {
+  if (!isRecord2(value) || typeof value.type !== "string") {
+    return "payload";
+  }
+  const base = camelToSnake(value.type);
+  if (value.kind === EnvelopeKind.RESPONSE) return `${base}_response`;
+  return base;
+}
+function pointerParts(pointer) {
+  if (pointer === "") return [];
+  return pointer.split("/").slice(1).map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function camelToSnake(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function uniqueStrings(value, index, all) {
+  return all.indexOf(value) === index;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripUndefined(value) {
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== void 0) {
+      out[key] = item;
+    }
+  }
+  return out;
+}
+function canonicalJsonStringify(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => canonicalJsonStringify(item)).join(",")}]`;
+  }
+  if (isRecord2(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJsonStringify(value[key])}`).join(",")}}`;
+  }
+  throw new CoordinatorError(ErrorCode.ERR_INVALID_PAYLOAD, "LP command contains non-JSON value");
+}
+function bytesToBase64Url(bytes) {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/u, "");
+}
+function base64UrlToBytes(value, field) {
+  const remainder = value.length % 4;
+  if (remainder === 1) {
+    throw new CoordinatorError(ErrorCode.ERR_INVALID_PAYLOAD, `${field} is invalid base64url`);
+  }
+  const padded = value.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - remainder) % 4);
+  const binary = atob(padded);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+var asSwapRequestPayload = (e) => e.payload;
+var asSwapRequestResponsePayload = (e) => e.payload;
+var asDkgInitPayload = (e) => e.payload;
+var asDkgInitResponsePayload = (e) => e.payload;
+var asDkgRound1Payload = (e) => e.payload;
+var asDkgRound1ResponsePayload = (e) => e.payload;
+var asDkgRound2Payload = (e) => e.payload;
+var asDkgRound2ResponsePayload = (e) => e.payload;
+var asDkgCompletePayload = (e) => e.payload;
+var asDelegateSharePayload = (e) => e.payload;
+var asDelegateShareResponsePayload = (e) => e.payload;
+var asDelegateAckPayload = (e) => e.payload;
+var asDepositConfirmedPayload = (e) => e.payload;
+var asSyncUserRequestPayload = (e) => e.payload;
+var asSyncUserResponsePayload = (e) => e.payload;
+var asSyncRequiredPayload = (e) => e.payload;
+var asPayoutExecutedPayload = (e) => e.payload;
+var asWithdrawRequestPayload = (e) => e.payload;
+var asWithdrawAcceptedPayload = (e) => e.payload;
+var asWithdrawExecutedPayload = (e) => e.payload;
+var asLpCommandResponsePayload = (e) => e.payload;
+var asErrorPayload = (e) => {
+  const payload = e.payload;
+  if (!isValidErrorCode(payload.code)) {
+    throw new CoordinatorError(
+      ErrorCode.ERR_INVALID_PAYLOAD,
+      `unknown error code ${String(payload.code)}`
+    );
+  }
+  return payload;
+};
+
+export { COORDINATOR_BINARY_FIELD_NAMES, COORDINATOR_ENVELOPE_SCHEMA, COORDINATOR_SCHEMA_PAYLOAD_CATEGORIES, CoordinatorError, CoordinatorMessageType, DEFAULT_PAYOUT_WINDOW_ID, DIRECTION_BY_TYPE, ENVELOPE_VERSION, EnvelopeKind, ErrorCode, INITIAL_STATE, MAX_FRAME_SIZE, MessageDirection, PAYOUT_WINDOW_OPTIONS, TERMINAL_STATES, TRANSITIONS, VALID_SWAP_STATES, asDelegateAckPayload, asDelegateSharePayload, asDelegateShareResponsePayload, asDepositConfirmedPayload, asDkgCompletePayload, asDkgInitPayload, asDkgInitResponsePayload, asDkgRound1Payload, asDkgRound1ResponsePayload, asDkgRound2Payload, asDkgRound2ResponsePayload, asErrorPayload, asLpCommandResponsePayload, asPayoutExecutedPayload, asSwapRequestPayload, asSwapRequestResponsePayload, asSyncRequiredPayload, asSyncUserRequestPayload, asSyncUserResponsePayload, asWithdrawAcceptedPayload, asWithdrawExecutedPayload, asWithdrawRequestPayload, decode, encode, encodeLpCommandForSigning, encodeValidated, isAllowedInState, isAllowedKindForType, isPayoutWindowId, isValidEnvelopeKind, isValidErrorCode, isValidMessageType, isValidSwapState, lpSignedCommandEnvelope, nextState, payloadCategory, payoutWindowLabelForId, payoutWindowOptionById, safeEncode, scheduledPayoutWindowOptions, scheduledPayoutWindowSeconds };
+//# sourceMappingURL=chunk-LBC7ALYO.js.map
+//# sourceMappingURL=chunk-LBC7ALYO.js.map