@bosonprotocol/x402-client 0.2.0 → 0.3.0-alpha-0

package/dist/esm/index.js

@@ -3,6 +3,7 @@ export { FulfillmentValidationError, MaxAmountExceededError, NoCompatibleActionE
 import Ajv from 'ajv';
 import { parseEscrowPaymentRequirements, DECIMAL_UINT, parseEscrowPaymentPayload } from '@bosonprotocol/x402-core/schemes/escrow';
 import { encodeSignedPayload } from '@bosonprotocol/x402-evm/codec';
+import { ExchangeState, DisputeState } from '@bosonprotocol/x402-core/state-machine';
 import { serializeTypedData, getAddress } from 'viem';
 
 // src/action.ts
@@ -34,6 +35,30 @@ function pickAction(requirements, policy) {
     `no commit-time action ('${FLOW_A}' or '${FLOW_B}') with 'server' channel found in requirements.actions.next`
   );
 }
+
+// src/base64.ts
+function decodeBase64(value) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(value, "base64").toString("utf8");
+  }
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+function encodeBase64(value) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(value, "utf8").toString("base64");
+  }
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const b of bytes) {
+    binary += String.fromCharCode(b);
+  }
+  return btoa(binary);
+}
 function resolveFulfillment(requirements, config) {
   const required = requirements.fulfillment?.required ?? false;
   if (!required) {
@@ -119,17 +144,6 @@ function isClientStateShape(v) {
   }
   return true;
 }
-function decodeBase64(value) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(value, "base64").toString("utf8");
-  }
-  const binary = atob(value);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return new TextDecoder().decode(bytes);
-}
 function pickString(obj, keys) {
   for (const key of keys) {
     const v = obj[key];
@@ -172,16 +186,7 @@ function assemblePayload({
 }
 function assembleAndEncodePayload(args) {
   const payload = assemblePayload(args);
-  const json = JSON.stringify(payload);
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(json, "utf8").toString("base64");
-  }
-  const bytes = new TextEncoder().encode(json);
-  let binary = "";
-  for (const b of bytes) {
-    binary += String.fromCharCode(b);
-  }
-  return btoa(binary);
+  return encodeBase64(JSON.stringify(payload));
 }
 
 // src/pre-commit.ts
@@ -280,6 +285,235 @@ async function callSignMetaTx(coreSdk, args, nonce) {
     }
   }
 }
+var SUBMIT_CHANNELS = ["server", "facilitator"];
+var NoCompatibleChannelError = class extends Error {
+  constructor(actionId, advertisedChannels) {
+    super(
+      `x402-client: action '${actionId}' advertises channels [${advertisedChannels.join(", ")}] but none are submittable over HTTP (server / facilitator).`
+    );
+    this.name = "NoCompatibleChannelError";
+    this.actionId = actionId;
+    this.advertisedChannels = advertisedChannels;
+  }
+};
+var AllChannelsFailedError = class extends Error {
+  constructor(actionId, attempts) {
+    super(
+      `x402-client: action '${actionId}' failed on every attempted channel \u2014 ${attempts.map((a) => formatAttempt(a)).join("; ")}`
+    );
+    this.name = "AllChannelsFailedError";
+    this.attempts = attempts;
+  }
+};
+function formatAttempt(a) {
+  if (a.ok) return `${a.channel}=ok(${a.status})`;
+  const tail = a.status !== void 0 ? `(${a.status})` : "";
+  return `${a.channel}=${a.reason}${tail}`;
+}
+async function submitAction(args) {
+  const fetcher = args.fetch ?? globalThis.fetch.bind(globalThis);
+  const timeoutMs = args.timeoutMs ?? 1e4;
+  const ordered = orderedChannels(args.action);
+  if (ordered.length === 0) {
+    throw new NoCompatibleChannelError(args.action.id, args.action.channels);
+  }
+  const attempts = [];
+  for (const channel of ordered) {
+    const endpoint = args.action.endpoints?.[channel];
+    if (endpoint === void 0) {
+      attempts.push({
+        channel,
+        ok: false,
+        reason: "no-endpoint",
+        message: `no endpoint advertised for channel '${channel}'`
+      });
+      continue;
+    }
+    const outcome = await attemptChannel({
+      channel,
+      endpoint,
+      args,
+      fetcher,
+      timeoutMs
+    });
+    attempts.push(outcome.attempt);
+    if (outcome.attempt.ok && outcome.result !== void 0) {
+      return { ...outcome.result, attempts };
+    }
+    if (!outcome.attempt.ok && outcome.attempt.reason === "4xx") {
+      throw new AllChannelsFailedError(args.action.id, attempts);
+    }
+  }
+  throw new AllChannelsFailedError(args.action.id, attempts);
+}
+function orderedChannels(action) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of action.channels) {
+    if (SUBMIT_CHANNELS.includes(c) && !seen.has(c)) {
+      seen.add(c);
+      out.push(c);
+    }
+  }
+  return out;
+}
+async function attemptChannel(input) {
+  const { channel, endpoint, args, fetcher, timeoutMs } = input;
+  const body = channel === "server" ? buildServerBody(args) : buildFacilitatorBody(args);
+  let res;
+  try {
+    res = await fetchWithTimeout(fetcher, endpoint, body, timeoutMs);
+  } catch (e) {
+    const reason = isTimeout(e) ? "timeout" : "network";
+    return {
+      attempt: {
+        channel,
+        ok: false,
+        reason,
+        message: e instanceof Error ? e.message : String(e)
+      }
+    };
+  }
+  const parsed = await res.json().catch(() => null);
+  if (res.status >= 500) {
+    return {
+      attempt: { channel, ok: false, reason: "5xx", status: res.status }
+    };
+  }
+  if (!res.ok) {
+    return {
+      attempt: { channel, ok: false, reason: "4xx", status: res.status }
+    };
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    return {
+      attempt: {
+        channel,
+        ok: false,
+        reason: "invalid-response",
+        status: res.status,
+        message: "response body is not a JSON object"
+      }
+    };
+  }
+  try {
+    const result = channel === "server" ? parseServerResult(parsed) : parseFacilitatorResult(parsed);
+    return {
+      attempt: { channel, ok: true, status: res.status },
+      result: { ...result, channelUsed: channel }
+    };
+  } catch (e) {
+    return {
+      attempt: {
+        channel,
+        ok: false,
+        reason: "invalid-response",
+        status: res.status,
+        message: e instanceof Error ? e.message : String(e)
+      }
+    };
+  }
+}
+function buildServerBody(args) {
+  const body = {
+    exchangeId: args.exchangeId,
+    signedPayload: args.signed.signedPayload
+  };
+  if (args.action.id === "boson-redeem" && args.fulfillment !== void 0) {
+    body.fulfillment = args.fulfillment;
+  }
+  return body;
+}
+function buildFacilitatorBody(args) {
+  return {
+    action: args.action.id,
+    exchangeId: args.exchangeId,
+    network: args.network,
+    escrowAddress: args.escrowAddress,
+    signedPayload: args.signed.signedPayload
+  };
+}
+async function fetchWithTimeout(fetcher, endpoint, body, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new TimeoutError(timeoutMs)), timeoutMs);
+  try {
+    return await fetcher(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var TimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`x402-client/submit: channel attempt timed out after ${timeoutMs}ms`);
+    this.isTimeout = true;
+    this.name = "TimeoutError";
+  }
+};
+function isTimeout(e) {
+  if (e instanceof TimeoutError) return true;
+  if (typeof e !== "object" || e === null) return false;
+  const obj = e;
+  if (obj.isTimeout === true) return true;
+  if (obj.name === "AbortError" || obj.name === "TimeoutError") return true;
+  if (typeof obj.cause === "object" && obj.cause !== null) {
+    const cause = obj.cause;
+    if (cause.isTimeout === true) return true;
+    if (cause.name === "TimeoutError") return true;
+  }
+  return false;
+}
+function parseServerResult(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new Error("server response body is not an object");
+  }
+  const raw = body;
+  const txHash = raw.txHash;
+  const exchangeState = raw.nextActions?.exchangeState;
+  if (!isHexHash(txHash) || !isExchangeState(exchangeState)) {
+    throw new Error("server response missing txHash or nextActions.exchangeState");
+  }
+  const out = {
+    txHash,
+    newExchangeState: exchangeState,
+    nextActions: raw.nextActions
+  };
+  if (isDisputeState(raw.nextActions?.disputeState)) {
+    out.newDisputeState = raw.nextActions.disputeState;
+  }
+  return out;
+}
+function parseFacilitatorResult(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new Error("facilitator response body is not an object");
+  }
+  const raw = body;
+  if (raw.ok !== true || !isHexHash(raw.txHash) || !isExchangeState(raw.newExchangeState)) {
+    throw new Error("facilitator response missing ok/txHash/newExchangeState");
+  }
+  const out = {
+    txHash: raw.txHash,
+    newExchangeState: raw.newExchangeState
+  };
+  if (isDisputeState(raw.newDisputeState)) {
+    out.newDisputeState = raw.newDisputeState;
+  }
+  return out;
+}
+var TX_HASH_RE = /^0x[0-9a-fA-F]{64}$/;
+function isHexHash(v) {
+  return typeof v === "string" && TX_HASH_RE.test(v);
+}
+function isExchangeState(v) {
+  return typeof v === "string" && Object.values(ExchangeState).includes(v);
+}
+function isDisputeState(v) {
+  return typeof v === "string" && Object.values(DisputeState).includes(v);
+}
 function normalizeEntityId(value) {
   if (typeof value === "bigint") {
     if (value < 0n) throw new Error(`entityId must be non-negative, got ${value.toString()}`);
@@ -492,6 +726,26 @@ function createX402bClient(config) {
     signAction(args) {
       return signPostCommitAction(args, { buildCoreSdk, getBuyerAddress });
     },
+    async submitAction(args) {
+      const signed = await signPostCommitAction(args, { buildCoreSdk, getBuyerAddress });
+      const action = args.priorNextActions.next.find((entry) => entry.id === args.actionId);
+      if (action === void 0) {
+        throw new Error(
+          `x402-client/submitAction: actionId '${args.actionId}' is not present in priorNextActions.next[]`
+        );
+      }
+      const submitArgs = {
+        action,
+        signed,
+        exchangeId: String(args.exchangeId),
+        network: args.network,
+        escrowAddress: args.escrowAddress,
+        fulfillment: args.fulfillment,
+        fetch: args.fetch,
+        timeoutMs: args.timeoutMs
+      };
+      return submitAction(submitArgs);
+    },
     signWithdrawFunds(args) {
       return signWithdrawFunds(args, { buildCoreSdk, getSignerAddress: getBuyerAddress });
     },
@@ -552,6 +806,6 @@ function deriveEip712DomainType(domain) {
   return fields;
 }
 
-export { createX402bClient, parsePaymentResponse, pickAction, resolveFulfillment, signerFromEthersAdapter };
+export { AllChannelsFailedError, NoCompatibleChannelError, createX402bClient, decodeBase64, encodeBase64, parsePaymentResponse, pickAction, resolveFulfillment, signerFromEthersAdapter, submitAction };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map