@arcanetech/privacy-sdk-relay 0.2.0

package/dist/index.js

@@ -0,0 +1,881 @@
+// src/json-safe.ts
+function jsonSafeClone(value) {
+  return JSON.parse(JSON.stringify(value, jsonSafeReplacer));
+}
+function jsonSafeReplacer(_key, value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return { type: "Buffer", data: [...value] };
+  }
+  return value;
+}
+
+// src/relay-config.ts
+function resolveRelayOrigin(origin) {
+  const trimmed = origin?.trim().replace(/\/$/u, "");
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed;
+}
+function isRelayConfigured(config) {
+  return Boolean(resolveRelayOrigin(config?.origin));
+}
+function requireRelayOrigin(origin) {
+  const resolved = resolveRelayOrigin(origin);
+  if (!resolved) {
+    throw new Error("Relay API origin is not configured.");
+  }
+  return resolved;
+}
+function requireRelayApi(ports) {
+  if (!ports.relayApi) {
+    throw new Error("Relay API is not configured.");
+  }
+  return ports.relayApi;
+}
+
+// src/reasons.ts
+var RELAY_PUBLIC_REASON = {
+  invalidPackage: "invalid_package",
+  unsupportedSignalShape: "unsupported_signal_shape",
+  positivePublicDeposit: "positive_public_deposit",
+  zkConfigMissing: "zk_config_missing",
+  zkConfigDeprecated: "zk_config_deprecated",
+  zkConfigIncompatible: "zk_config_incompatible",
+  invalidProof: "invalid_proof",
+  kytRejected: "kyt_rejected",
+  kytAuthorizationMismatch: "kyt_authorization_mismatch",
+  escrowRelayUnconfigured: "escrow_relay_unconfigured",
+  escrowAuthorizationMismatch: "escrow_authorization_mismatch",
+  nullifiersSpent: "nullifiers_spent",
+  simulationFailed: "simulation_failed",
+  resourceFeeExceeded: "resource_fee_exceeded",
+  resourceLimitExceeded: "resource_limit_exceeded",
+  sendFailed: "send_failed",
+  transactionFailed: "transaction_failed",
+  infrastructureFailed: "infrastructure_failed"
+};
+var RELAY_HTTP_REASON = {
+  payloadTooLarge: "payload_too_large",
+  rateLimited: "rate_limited",
+  unsupportedPool: "unsupported_pool",
+  queueAtCapacity: "queue_at_capacity",
+  lowBalance: "low_balance",
+  conflictingPayload: "conflicting_payload",
+  retryNotAllowed: "retry_not_allowed",
+  notFound: "not_found",
+  relayerUnavailable: "relayer_unavailable",
+  invalidPackage: "invalid_package",
+  unsupportedSignalShape: "unsupported_signal_shape"
+};
+var REJECTION_REASONS = /* @__PURE__ */ new Set([
+  RELAY_PUBLIC_REASON.invalidPackage,
+  RELAY_PUBLIC_REASON.unsupportedSignalShape,
+  RELAY_PUBLIC_REASON.positivePublicDeposit,
+  RELAY_PUBLIC_REASON.zkConfigMissing,
+  RELAY_PUBLIC_REASON.zkConfigDeprecated,
+  RELAY_PUBLIC_REASON.zkConfigIncompatible,
+  RELAY_PUBLIC_REASON.invalidProof,
+  RELAY_PUBLIC_REASON.kytRejected,
+  RELAY_PUBLIC_REASON.kytAuthorizationMismatch,
+  RELAY_PUBLIC_REASON.escrowRelayUnconfigured,
+  RELAY_PUBLIC_REASON.escrowAuthorizationMismatch,
+  RELAY_PUBLIC_REASON.nullifiersSpent,
+  RELAY_PUBLIC_REASON.simulationFailed,
+  RELAY_PUBLIC_REASON.resourceFeeExceeded,
+  RELAY_PUBLIC_REASON.resourceLimitExceeded
+]);
+var RETRYABLE_FAILURE_REASONS = /* @__PURE__ */ new Set([
+  RELAY_PUBLIC_REASON.sendFailed,
+  RELAY_PUBLIC_REASON.transactionFailed,
+  RELAY_PUBLIC_REASON.infrastructureFailed
+]);
+var RELAY_INFRASTRUCTURE_HTTP_REASONS = /* @__PURE__ */ new Set([
+  RELAY_HTTP_REASON.rateLimited,
+  RELAY_HTTP_REASON.queueAtCapacity,
+  RELAY_HTTP_REASON.lowBalance,
+  RELAY_HTTP_REASON.relayerUnavailable,
+  RELAY_HTTP_REASON.payloadTooLarge
+]);
+function isRetryableFailureReason(reason) {
+  if (!reason) {
+    return false;
+  }
+  return RETRYABLE_FAILURE_REASONS.has(reason);
+}
+function isRejectionReason(reason) {
+  return REJECTION_REASONS.has(reason);
+}
+
+// src/relay-api-error.ts
+var RelayApiError = class extends Error {
+  reason;
+  httpStatus;
+  constructor(input) {
+    super(input.reason);
+    this.name = "RelayApiError";
+    this.reason = input.reason;
+    this.httpStatus = input.httpStatus;
+  }
+};
+function isInfrastructureRelayFailure(error) {
+  return RELAY_INFRASTRUCTURE_HTTP_REASONS.has(error.reason);
+}
+function isRelayApiError(error) {
+  return error instanceof RelayApiError;
+}
+
+// src/relay-api.ts
+var HTTP_OK = 200;
+var HTTP_ACCEPTED = 202;
+function asRecord(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function readReason(payload, fallback) {
+  const record = asRecord(payload);
+  return typeof record.reason === "string" && record.reason.trim() ? record.reason : fallback;
+}
+async function parseJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}
+async function requestJson(input) {
+  const init = {
+    method: input.method,
+    headers: { Accept: "application/json" }
+  };
+  if (input.body) {
+    init.headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    init.body = JSON.stringify(input.body);
+  }
+  const response = await input.fetch(input.url, init);
+  const payload = await parseJson(response);
+  return { httpStatus: response.status, payload };
+}
+function requireOkStatus(input) {
+  if (input.allowed.includes(input.httpStatus)) {
+    return asRecord(input.payload);
+  }
+  throw new RelayApiError({
+    reason: readReason(input.payload, RELAY_PUBLIC_REASON.infrastructureFailed),
+    httpStatus: input.httpStatus
+  });
+}
+function mapAccepted(record) {
+  return {
+    relayRequestId: String(record.relayRequestId ?? ""),
+    status: String(record.status ?? "accepted"),
+    createdAt: String(record.createdAt ?? ""),
+    statusUrl: String(record.statusUrl ?? "")
+  };
+}
+function mapStatus(record) {
+  const status = {
+    relayRequestId: String(record.relayRequestId ?? ""),
+    status: String(record.status ?? ""),
+    createdAt: String(record.createdAt ?? ""),
+    updatedAt: String(record.updatedAt ?? ""),
+    retryAllowed: record.retryAllowed === true
+  };
+  if (typeof record.attemptNumber === "number") {
+    status.attemptNumber = record.attemptNumber;
+  }
+  if (typeof record.transactionHash === "string") {
+    status.transactionHash = record.transactionHash;
+  }
+  if (typeof record.publicReason === "string") {
+    status.publicReason = record.publicReason;
+  }
+  return status;
+}
+function resolveFetcher(input) {
+  return input.fetch ?? globalThis.fetch.bind(globalThis);
+}
+function createRelayApi(input) {
+  const origin = requireRelayOrigin(input.origin);
+  const fetchImpl = resolveFetcher(input);
+  return {
+    async createRequest(body) {
+      const result = await requestJson({
+        fetch: fetchImpl,
+        url: `${origin}/relay-requests`,
+        method: "POST",
+        body
+      });
+      return mapAccepted(
+        requireOkStatus({
+          httpStatus: result.httpStatus,
+          payload: result.payload,
+          allowed: [HTTP_ACCEPTED]
+        })
+      );
+    },
+    async readStatus(relayRequestId) {
+      const result = await requestJson({
+        fetch: fetchImpl,
+        url: `${origin}/relay-requests/${relayRequestId}`,
+        method: "GET"
+      });
+      return mapStatus(
+        requireOkStatus({
+          httpStatus: result.httpStatus,
+          payload: result.payload,
+          allowed: [HTTP_OK]
+        })
+      );
+    },
+    async retryAttempt(relayRequestId) {
+      const result = await requestJson({
+        fetch: fetchImpl,
+        url: `${origin}/relay-requests/${relayRequestId}/attempts`,
+        method: "POST"
+      });
+      return mapStatus(
+        requireOkStatus({
+          httpStatus: result.httpStatus,
+          payload: result.payload,
+          allowed: [HTTP_OK]
+        })
+      );
+    }
+  };
+}
+
+// src/types.ts
+var SUBMISSION_PATH = {
+  direct: "direct",
+  relay: "relay"
+};
+var RELAY_STATUS = {
+  accepted: "accepted",
+  validating: "validating",
+  queued: "queued",
+  submitted: "submitted",
+  reconciling: "reconciling",
+  succeeded: "succeeded",
+  rejected: "rejected",
+  failed: "failed"
+};
+var PENDING_OPERATION_PHASE = {
+  prepared: "prepared",
+  relayAccepted: "relay_accepted",
+  admissionFailed: "admission_failed",
+  succeeded: "succeeded",
+  rejected: "rejected",
+  failed: "failed",
+  settlementTimedOut: "settlement_timed_out"
+};
+
+// src/fallback-policy.ts
+var BLOCKED_DIRECT_STATUSES = /* @__PURE__ */ new Set([
+  RELAY_STATUS.submitted,
+  RELAY_STATUS.reconciling,
+  RELAY_STATUS.rejected,
+  RELAY_STATUS.succeeded
+]);
+function canOfferDirectSubmission(operation) {
+  if (operation.escrowSend) {
+    return false;
+  }
+  if (operation.finalized) {
+    return false;
+  }
+  if (operation.relayStatus && BLOCKED_DIRECT_STATUSES.has(operation.relayStatus)) {
+    return false;
+  }
+  if (operation.phase === PENDING_OPERATION_PHASE.rejected) {
+    return false;
+  }
+  if (operation.phase === PENDING_OPERATION_PHASE.failed) {
+    return false;
+  }
+  if (operation.relayRequestId) {
+    return false;
+  }
+  return operation.phase === PENDING_OPERATION_PHASE.prepared || operation.phase === PENDING_OPERATION_PHASE.admissionFailed;
+}
+function canRetryRelayAttempt(operation) {
+  if (operation.finalized || !operation.relayRequestId) {
+    return false;
+  }
+  return operation.phase === PENDING_OPERATION_PHASE.failed && operation.retryAllowed;
+}
+
+// src/is-unfinalized-relay-operation.ts
+function isUnfinalizedRelayOperation(operation) {
+  return Boolean(operation.relayRequestId) && !operation.finalized;
+}
+
+// src/complete-succeeded-operation.ts
+var inFlightCompletions = /* @__PURE__ */ new Map();
+function toSubmitResult(operation, extras) {
+  const result = {
+    outcome: operation.phase,
+    operation,
+    fallbackAllowed: canOfferDirectSubmission(operation),
+    retryAllowed: canRetryRelayAttempt(operation)
+  };
+  if (extras?.txId) {
+    result.txId = extras.txId;
+  }
+  if (extras?.coinDeliveryWarning) {
+    result.coinDeliveryWarning = extras.coinDeliveryWarning;
+  }
+  return result;
+}
+async function requireStoredOperation(input) {
+  const operation = await input.ports.store.read({
+    walletPublicKey: input.walletPublicKey,
+    operationId: input.operationId
+  });
+  if (!operation) {
+    throw new Error("Pending private operation was not found.");
+  }
+  return operation;
+}
+function successKey(operation, txId) {
+  return `${operation.walletPublicKey}:${operation.id}:${txId}`;
+}
+function withSucceededPhase(operation, txId) {
+  return {
+    ...operation,
+    phase: PENDING_OPERATION_PHASE.succeeded,
+    relayStatus: "succeeded",
+    transactionHash: txId,
+    retryAllowed: false
+  };
+}
+function isAlreadyCompleted(operation) {
+  return operation.finalized && operation.deliveriesDrained && operation.transactionPersisted;
+}
+async function applySuccessSideEffects(input) {
+  let current = input.operation;
+  let warning;
+  if (!current.finalized) {
+    await input.ports.finalizeLocalState({
+      operation: current,
+      txId: input.txId
+    });
+    current = { ...current, finalized: true };
+    await input.ports.store.save(current);
+  }
+  if (!current.deliveriesDrained) {
+    warning = await input.ports.drainDeliveries({
+      operation: current,
+      txId: input.txId
+    });
+    current = { ...current, deliveriesDrained: true };
+    await input.ports.store.save(current);
+  }
+  if (!current.transactionPersisted) {
+    input.ports.persistUserTransaction({
+      operation: current,
+      txId: input.txId
+    });
+    current = { ...current, transactionPersisted: true };
+    await input.ports.store.save(current);
+  }
+  return warning === void 0 ? { operation: current } : { operation: current, warning };
+}
+async function applySucceededCompletion(input) {
+  const applied = await applySuccessSideEffects(input);
+  await input.ports.store.save(applied.operation);
+  return toSubmitResult(applied.operation, {
+    txId: input.txId,
+    ...applied.warning ? { coinDeliveryWarning: applied.warning } : {}
+  });
+}
+async function completeSucceededOperation(input) {
+  const stored = await input.ports.store.read({
+    walletPublicKey: input.operation.walletPublicKey,
+    operationId: input.operation.id
+  });
+  const succeeded = withSucceededPhase(stored ?? input.operation, input.txId);
+  const key = successKey(succeeded, input.txId);
+  if (isAlreadyCompleted(succeeded)) {
+    await input.ports.store.save(succeeded);
+    return toSubmitResult(succeeded, { txId: input.txId });
+  }
+  const existing = inFlightCompletions.get(key);
+  if (existing) {
+    return existing;
+  }
+  const completion = applySucceededCompletion({
+    ports: input.ports,
+    operation: succeeded,
+    txId: input.txId
+  });
+  inFlightCompletions.set(key, completion);
+  try {
+    return await completion;
+  } finally {
+    inFlightCompletions.delete(key);
+  }
+}
+
+// src/submit-prepared-private-operation.ts
+function buildPreparedOperation(input) {
+  return {
+    id: input.id,
+    walletPublicKey: input.walletPublicKey,
+    phase: PENDING_OPERATION_PHASE.prepared,
+    retryAllowed: false,
+    display: input.display,
+    snapshot: input.snapshot,
+    deliveryOutbox: input.deliveryOutbox,
+    relayPackage: input.relayPackage,
+    finalized: false,
+    deliveriesDrained: false,
+    transactionPersisted: false,
+    ...input.escrowSend ? { escrowSend: true } : {}
+  };
+}
+async function submitDirectPath(input) {
+  const receipt = await input.ports.submitDirect(input.operation);
+  return completeSucceededOperation({
+    ports: input.ports,
+    operation: input.operation,
+    txId: receipt.txId
+  });
+}
+async function saveAdmissionFailure(input) {
+  const failed = {
+    ...input.operation,
+    phase: PENDING_OPERATION_PHASE.admissionFailed,
+    publicReason: input.reason,
+    retryAllowed: false
+  };
+  await input.ports.store.save(failed);
+  return toSubmitResult(failed);
+}
+async function saveRejectedWithoutRequest(input) {
+  const rejected = {
+    ...input.operation,
+    phase: PENDING_OPERATION_PHASE.rejected,
+    publicReason: input.reason,
+    retryAllowed: false
+  };
+  await input.ports.store.save(rejected);
+  return toSubmitResult(rejected);
+}
+async function createRelayRequest(input) {
+  const relayApi = requireRelayApi(input.ports);
+  await input.ports.store.save(input.operation);
+  try {
+    const accepted = await relayApi.createRequest(input.operation.relayPackage);
+    const stored = {
+      ...input.operation,
+      phase: PENDING_OPERATION_PHASE.relayAccepted,
+      relayRequestId: accepted.relayRequestId,
+      relayStatus: RELAY_STATUS.accepted,
+      retryAllowed: false
+    };
+    await input.ports.store.save(stored);
+    return toSubmitResult(stored);
+  } catch (error) {
+    const reason = error instanceof RelayApiError ? error.reason : RELAY_PUBLIC_REASON.infrastructureFailed;
+    if (error instanceof RelayApiError && !isInfrastructureRelayFailure(error)) {
+      return saveRejectedWithoutRequest({
+        ports: input.ports,
+        operation: input.operation,
+        reason
+      });
+    }
+    return saveAdmissionFailure({
+      ports: input.ports,
+      operation: input.operation,
+      reason
+    });
+  }
+}
+function shouldSubmitDirect(input) {
+  if (input.operation.escrowSend) {
+    return false;
+  }
+  return input.operation.submissionPath === SUBMISSION_PATH.direct || !isRelayConfigured(input.ports.relayConfig);
+}
+async function submitPreparedPrivateOperation(input) {
+  const prepared = buildPreparedOperation(input.operation);
+  if (input.operation.escrowSend && !isRelayConfigured(input.ports.relayConfig)) {
+    return saveRejectedWithoutRequest({
+      ports: input.ports,
+      operation: prepared,
+      reason: RELAY_PUBLIC_REASON.escrowRelayUnconfigured
+    });
+  }
+  if (shouldSubmitDirect(input)) {
+    return submitDirectPath({
+      ports: input.ports,
+      operation: prepared
+    });
+  }
+  return createRelayRequest({
+    ports: input.ports,
+    operation: prepared
+  });
+}
+
+// src/poll-pending-operation.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  RELAY_STATUS.succeeded,
+  RELAY_STATUS.rejected,
+  RELAY_STATUS.failed
+]);
+function isRelayStatus(value) {
+  return Object.values(RELAY_STATUS).includes(value);
+}
+function applyStatus(operation, status) {
+  const next = {
+    ...operation,
+    retryAllowed: status.retryAllowed
+  };
+  if (isRelayStatus(status.status)) {
+    next.relayStatus = status.status;
+  }
+  if (status.publicReason) {
+    next.publicReason = status.publicReason;
+  }
+  if (status.transactionHash) {
+    next.transactionHash = status.transactionHash;
+  }
+  if (status.status === RELAY_STATUS.rejected) {
+    next.phase = PENDING_OPERATION_PHASE.rejected;
+    next.retryAllowed = false;
+  }
+  if (status.status === RELAY_STATUS.failed) {
+    next.phase = PENDING_OPERATION_PHASE.failed;
+  }
+  return next;
+}
+async function pollPendingOperation(input) {
+  const operation = await requireStoredOperation(input);
+  if (!operation.relayRequestId) {
+    return toSubmitResult(operation);
+  }
+  const status = await requireRelayApi(input.ports).readStatus(
+    operation.relayRequestId
+  );
+  const updated = applyStatus(operation, status);
+  await input.ports.store.save(updated);
+  if (status.status === RELAY_STATUS.succeeded && status.transactionHash) {
+    return completeSucceededOperation({
+      ports: input.ports,
+      operation: updated,
+      txId: status.transactionHash
+    });
+  }
+  return toSubmitResult(updated, {
+    ...updated.transactionHash ? { txId: updated.transactionHash } : {}
+  });
+}
+function isTerminalRelayStatus(status) {
+  return Boolean(status && TERMINAL_STATUSES.has(status));
+}
+
+// src/retry-and-resume.ts
+function withoutPublicReason(operation) {
+  const next = { ...operation };
+  delete next.publicReason;
+  return next;
+}
+async function retryFailedRelayAttempt(input) {
+  const operation = await requireStoredOperation(input);
+  if (!canRetryRelayAttempt(operation) || !operation.relayRequestId) {
+    throw new Error("Relay retry is not allowed for this operation.");
+  }
+  await requireRelayApi(input.ports).retryAttempt(operation.relayRequestId);
+  await input.ports.store.save({
+    ...withoutPublicReason(operation),
+    phase: PENDING_OPERATION_PHASE.relayAccepted,
+    relayStatus: RELAY_STATUS.accepted,
+    retryAllowed: false
+  });
+  return pollPendingOperation(input);
+}
+async function resumePendingOperations(input) {
+  const listed = await input.ports.store.list(input.walletPublicKey);
+  const pending = listed.filter((operation) => isUnfinalizedRelayOperation(operation));
+  const results = [];
+  for (const operation of pending) {
+    results.push(
+      await pollPendingOperation({
+        ports: input.ports,
+        walletPublicKey: input.walletPublicKey,
+        operationId: operation.id
+      })
+    );
+  }
+  return results;
+}
+
+// src/submit-direct-fallback.ts
+async function submitDirectFallback(input) {
+  const operation = await requireStoredOperation(input);
+  if (!input.consent || !canOfferDirectSubmission(operation)) {
+    throw new Error("Direct submission fallback is not allowed.");
+  }
+  const receipt = await input.ports.submitDirect(operation);
+  return completeSucceededOperation({
+    ports: input.ports,
+    operation,
+    txId: receipt.txId
+  });
+}
+
+// src/await-relay-settlement.ts
+var DEFAULT_SETTLEMENT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_SETTLEMENT_MAX_ATTEMPTS = 15;
+var DEFAULT_SETTLEMENT_BACKOFF_MULTIPLIER = 2;
+var DEFAULT_SETTLEMENT_MAX_INTERVAL_MS = 3e4;
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isSettled(result) {
+  return result.outcome === PENDING_OPERATION_PHASE.succeeded || result.outcome === PENDING_OPERATION_PHASE.rejected || result.outcome === PENDING_OPERATION_PHASE.failed || result.outcome === PENDING_OPERATION_PHASE.admissionFailed || result.outcome === PENDING_OPERATION_PHASE.settlementTimedOut || isTerminalRelayStatus(result.operation.relayStatus);
+}
+function nextPollDelayMs(input) {
+  return Math.min(
+    input.pollIntervalMs * input.backoffMultiplier ** input.attemptIndex,
+    input.maxPollIntervalMs
+  );
+}
+async function markSettlementTimedOut(input) {
+  const timedOut = {
+    ...input.operation,
+    phase: PENDING_OPERATION_PHASE.settlementTimedOut
+  };
+  await input.ports.store.save(timedOut);
+  return toSubmitResult(timedOut);
+}
+async function pollUntilBound(input) {
+  let result = await pollPendingOperation(input);
+  let attemptIndex = 0;
+  while (!isSettled(result) && attemptIndex + 1 < input.maxAttempts) {
+    await input.delay(
+      nextPollDelayMs({
+        attemptIndex,
+        pollIntervalMs: input.pollIntervalMs,
+        backoffMultiplier: input.backoffMultiplier,
+        maxPollIntervalMs: input.maxPollIntervalMs
+      })
+    );
+    result = await pollPendingOperation(input);
+    attemptIndex += 1;
+  }
+  return result;
+}
+function resolvePollBounds(input) {
+  return {
+    ports: input.ports,
+    walletPublicKey: input.walletPublicKey,
+    operationId: input.operationId,
+    pollIntervalMs: input.pollIntervalMs ?? DEFAULT_SETTLEMENT_POLL_INTERVAL_MS,
+    maxAttempts: input.maxAttempts ?? DEFAULT_SETTLEMENT_MAX_ATTEMPTS,
+    backoffMultiplier: input.backoffMultiplier ?? DEFAULT_SETTLEMENT_BACKOFF_MULTIPLIER,
+    maxPollIntervalMs: input.maxPollIntervalMs ?? DEFAULT_SETTLEMENT_MAX_INTERVAL_MS,
+    delay: input.delay ?? delay
+  };
+}
+async function awaitRelaySettlement(input) {
+  const result = await pollUntilBound(resolvePollBounds(input));
+  if (isSettled(result)) {
+    return result;
+  }
+  return markSettlementTimedOut({
+    ports: input.ports,
+    operation: result.operation
+  });
+}
+async function submitAndAwaitPrivateOperation(input) {
+  const submitted = await submitPreparedPrivateOperation(input);
+  if (submitted.outcome !== PENDING_OPERATION_PHASE.relayAccepted) {
+    return submitted;
+  }
+  return awaitRelaySettlement({
+    ports: input.ports,
+    walletPublicKey: input.operation.walletPublicKey,
+    operationId: input.operation.id,
+    ...input.pollIntervalMs === void 0 ? {} : { pollIntervalMs: input.pollIntervalMs },
+    ...input.maxAttempts === void 0 ? {} : { maxAttempts: input.maxAttempts }
+  });
+}
+
+// src/protocol-relay-client-error.ts
+var ProtocolRelayClientError = class extends Error {
+  outcome;
+  fallbackAllowed;
+  retryAllowed;
+  operationId;
+  publicReason;
+  constructor(result) {
+    super(result.operation.publicReason ?? result.outcome);
+    this.name = "ProtocolRelayClientError";
+    this.outcome = result.outcome;
+    this.fallbackAllowed = result.fallbackAllowed;
+    this.retryAllowed = result.retryAllowed;
+    this.operationId = result.operation.id;
+    if (result.operation.publicReason) {
+      this.publicReason = result.operation.publicReason;
+    }
+  }
+};
+function throwIfRelayUnsuccessful(result) {
+  if (result.outcome === PENDING_OPERATION_PHASE.succeeded && result.txId) {
+    return {
+      txId: result.txId,
+      ...result.coinDeliveryWarning ? { coinDeliveryWarning: result.coinDeliveryWarning } : {}
+    };
+  }
+  throw new ProtocolRelayClientError(result);
+}
+
+// src/serialize.ts
+var RELAY_PACKAGE_VERSION_V1 = 1;
+function nonceToString(value) {
+  return typeof value === "string" ? value : value.toString();
+}
+function copyKeyVersionHints(hints) {
+  return hints.map((value) => typeof value === "number" ? value : void 0);
+}
+function serializeRelayPackage(source) {
+  const body = {
+    version: source.version,
+    poolSelector: source.poolSelector,
+    zkConfigNonce: nonceToString(source.zkConfigNonce),
+    proofBytes: source.proofBytes,
+    publicSignals: source.publicSignals,
+    applicationIdHints: [...source.applicationIdHints]
+  };
+  if (source.ciphertextBytes !== void 0) {
+    body.ciphertextBytes = source.ciphertextBytes;
+  }
+  if (source.outputNoteEphemeralScalars !== void 0) {
+    body.outputNoteEphemeralScalars = [...source.outputNoteEphemeralScalars];
+  }
+  if (source.escrowAuthorization !== void 0) {
+    body.escrowAuthorization = source.escrowAuthorization;
+  }
+  if (source.keyVersionHints) {
+    body.keyVersionHints = copyKeyVersionHints(source.keyVersionHints);
+  }
+  return body;
+}
+function readNonce(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return void 0;
+}
+function readHints(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.map((entry) => typeof entry === "number" ? entry : void 0);
+}
+function readStringArray(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return void 0;
+  }
+  if (!value.every((entry) => typeof entry === "string")) {
+    return void 0;
+  }
+  return value;
+}
+function readApplicationIdHints(value) {
+  return readStringArray(value);
+}
+function readWireRecord(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return void 0;
+  }
+  return payload;
+}
+function deserializeRelayPackage(payload) {
+  const record = readWireRecord(payload);
+  if (!record || record.version !== RELAY_PACKAGE_VERSION_V1 || typeof record.proofBytes !== "string") {
+    return void 0;
+  }
+  if (typeof record.poolSelector !== "string" || typeof record.publicSignals !== "string") {
+    return void 0;
+  }
+  const zkConfigNonce = readNonce(record.zkConfigNonce);
+  const applicationIdHints = readApplicationIdHints(record.applicationIdHints);
+  if (!zkConfigNonce || !applicationIdHints) {
+    return void 0;
+  }
+  const body = {
+    version: RELAY_PACKAGE_VERSION_V1,
+    poolSelector: record.poolSelector,
+    zkConfigNonce,
+    proofBytes: record.proofBytes,
+    publicSignals: record.publicSignals,
+    applicationIdHints
+  };
+  if (typeof record.ciphertextBytes === "string") {
+    body.ciphertextBytes = record.ciphertextBytes;
+  }
+  const outputNoteEphemeralScalars = readStringArray(record.outputNoteEphemeralScalars);
+  if (outputNoteEphemeralScalars) {
+    body.outputNoteEphemeralScalars = outputNoteEphemeralScalars;
+  }
+  if (typeof record.escrowAuthorization === "string") {
+    body.escrowAuthorization = record.escrowAuthorization;
+  }
+  const keyVersionHints = readHints(record.keyVersionHints);
+  if (keyVersionHints) {
+    body.keyVersionHints = keyVersionHints;
+  }
+  return body;
+}
+export {
+  DEFAULT_SETTLEMENT_MAX_ATTEMPTS,
+  DEFAULT_SETTLEMENT_POLL_INTERVAL_MS,
+  PENDING_OPERATION_PHASE,
+  ProtocolRelayClientError,
+  RELAY_HTTP_REASON,
+  RELAY_PACKAGE_VERSION_V1,
+  RELAY_PUBLIC_REASON,
+  RELAY_STATUS,
+  RelayApiError,
+  SUBMISSION_PATH,
+  awaitRelaySettlement,
+  canOfferDirectSubmission,
+  canRetryRelayAttempt,
+  createRelayApi,
+  deserializeRelayPackage,
+  isInfrastructureRelayFailure,
+  isRejectionReason,
+  isRelayApiError,
+  isRelayConfigured,
+  isRetryableFailureReason,
+  isTerminalRelayStatus,
+  isUnfinalizedRelayOperation,
+  jsonSafeClone,
+  pollPendingOperation,
+  resolveRelayOrigin,
+  resumePendingOperations,
+  retryFailedRelayAttempt,
+  serializeRelayPackage,
+  submitAndAwaitPrivateOperation,
+  submitDirectFallback,
+  submitPreparedPrivateOperation,
+  throwIfRelayUnsuccessful
+};
+//# sourceMappingURL=index.js.map