@dtelecom/x402-client 0.1.0

package/dist/index.mjs

@@ -0,0 +1,369 @@
+// src/client.ts
+import { createPublicClient, http } from "viem";
+import { base } from "viem/chains";
+import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { toClientEvmSigner } from "@x402/evm";
+
+// src/auth.ts
+async function createAuthHeaders(account, method, path) {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const pathname = path.split("?")[0];
+  const message = `${method}
+${pathname}
+${timestamp}`;
+  const signature = await account.signMessage({ message });
+  return {
+    Authorization: `evm:${signature}`,
+    "X-Wallet-Address": account.address,
+    "X-Wallet-Chain": "evm",
+    "X-Timestamp": timestamp
+  };
+}
+
+// src/errors.ts
+var GatewayError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "GatewayError";
+    this.status = status;
+  }
+};
+var InsufficientCreditsError = class extends GatewayError {
+  constructor(message) {
+    super(message, 402);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var ConcurrencyLimitError = class extends GatewayError {
+  constructor(message) {
+    super(message, 429);
+    this.name = "ConcurrencyLimitError";
+  }
+};
+var RateLimitError = class extends GatewayError {
+  constructor(message) {
+    super(message, 429);
+    this.name = "RateLimitError";
+  }
+};
+var NoCapacityError = class extends GatewayError {
+  service;
+  constructor(message, service) {
+    super(message, 503);
+    this.name = "NoCapacityError";
+    this.service = service;
+  }
+};
+var PaymentError = class extends GatewayError {
+  constructor(message) {
+    super(message, 402);
+    this.name = "PaymentError";
+  }
+};
+
+// src/client.ts
+var DtelecomGateway = class {
+  baseUrl;
+  account;
+  fetchWithPayment;
+  constructor(config) {
+    this.baseUrl = config.gatewayUrl.replace(/\/+$/, "");
+    this.account = config.account;
+    const publicClient = createPublicClient({ chain: base, transport: http() });
+    const signer = toClientEvmSigner(config.account, publicClient);
+    const x402 = new x402Client();
+    registerExactEvmScheme(x402, { signer });
+    this.fetchWithPayment = wrapFetchWithPayment(fetch, x402);
+  }
+  // --- Credits ---
+  async buyCredits(options) {
+    const r = await this.requestWithPayment("/v1/credits/purchase", {
+      wallet_address: this.account.address,
+      wallet_chain: "evm",
+      amount_usd: options.amountUsd
+    });
+    return {
+      accountId: r.account_id,
+      creditedMicrocredits: r.credited_microcredits,
+      amountUsd: r.amount_usd
+    };
+  }
+  // --- Account ---
+  async getAccount() {
+    const r = await this.request("GET", "/v1/account");
+    return {
+      id: r.id,
+      walletAddress: r.wallet_address,
+      walletChain: r.wallet_chain,
+      creditBalance: r.credit_balance,
+      availableBalance: r.available_balance,
+      maxConcurrentSessions: r.max_concurrent_sessions,
+      maxApiRate: r.max_api_rate,
+      createdAt: r.created_at
+    };
+  }
+  async getTransactions(options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.offset !== void 0)
+      params.set("offset", String(options.offset));
+    const qs = params.toString();
+    const r = await this.request(
+      "GET",
+      `/v1/account/transactions${qs ? `?${qs}` : ""}`
+    );
+    return {
+      transactions: r.transactions.map(mapTransaction),
+      limit: r.limit,
+      offset: r.offset
+    };
+  }
+  async getSessions(options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.offset !== void 0)
+      params.set("offset", String(options.offset));
+    if (options?.status) params.set("status", options.status);
+    const qs = params.toString();
+    const r = await this.request(
+      "GET",
+      `/v1/account/sessions${qs ? `?${qs}` : ""}`
+    );
+    return {
+      sessions: r.sessions.map(mapSession),
+      limit: r.limit,
+      offset: r.offset
+    };
+  }
+  // --- Bundled Agent Session ---
+  async createAgentSession(options) {
+    const r = await this.request("POST", "/v1/agent-session", {
+      room_name: options.roomName,
+      participant_identity: options.participantIdentity,
+      duration_minutes: options.durationMinutes,
+      language: options.language,
+      tts_max_characters: options.ttsMaxCharacters,
+      metadata: options.metadata
+    });
+    return {
+      bundleId: r.bundle_id,
+      webrtc: {
+        sessionId: r.webrtc.session_id,
+        token: r.webrtc.token,
+        wsUrl: r.webrtc.ws_url
+      },
+      stt: {
+        sessionId: r.stt.session_id,
+        token: r.stt.token,
+        serverUrl: r.stt.server_url
+      },
+      tts: {
+        sessionId: r.tts.session_id,
+        token: r.tts.token,
+        serverUrl: r.tts.server_url
+      },
+      expiresAt: r.expires_at
+    };
+  }
+  async extendAgentSession(options) {
+    const r = await this.request("POST", "/v1/agent-session/extend", {
+      bundle_id: options.bundleId,
+      additional_minutes: options.additionalMinutes,
+      additional_tts_characters: options.additionalTtsCharacters
+    });
+    const result = {};
+    if (r.webrtc) {
+      result.webrtc = {
+        token: r.webrtc.token,
+        newExpiresAt: r.webrtc.new_expires_at
+      };
+    }
+    if (r.stt) {
+      result.stt = {
+        token: r.stt.token,
+        newExpiresAt: r.stt.new_expires_at
+      };
+    }
+    if (r.tts) {
+      result.tts = {
+        token: r.tts.token,
+        newExpiresAt: r.tts.new_expires_at
+      };
+    }
+    return result;
+  }
+  // --- Standalone WebRTC ---
+  async createWebRTCToken(options) {
+    const r = await this.request("POST", "/v1/webrtc/token", {
+      room_name: options.roomName,
+      participant_identity: options.participantIdentity,
+      duration_minutes: options.durationMinutes,
+      metadata: options.metadata
+    });
+    return {
+      sessionId: r.session_id,
+      token: r.token,
+      wsUrl: r.ws_url,
+      expiresAt: r.expires_at
+    };
+  }
+  async extendWebRTCToken(options) {
+    const r = await this.request("POST", "/v1/webrtc/token/extend", {
+      session_id: options.sessionId,
+      additional_minutes: options.additionalMinutes
+    });
+    return {
+      token: r.token,
+      wsUrl: r.ws_url,
+      newExpiresAt: r.new_expires_at
+    };
+  }
+  // --- Standalone STT ---
+  async createSTTSession(options) {
+    const r = await this.request("POST", "/v1/stt/session", {
+      duration_minutes: options.durationMinutes,
+      language: options.language
+    });
+    return {
+      sessionId: r.session_id,
+      token: r.token,
+      serverUrl: r.server_url,
+      expiresAt: r.expires_at
+    };
+  }
+  async extendSTTSession(options) {
+    const r = await this.request("POST", "/v1/stt/session/extend", {
+      session_id: options.sessionId,
+      additional_minutes: options.additionalMinutes
+    });
+    return {
+      token: r.token,
+      newExpiresAt: r.new_expires_at
+    };
+  }
+  // --- Standalone TTS ---
+  async createTTSSession(options) {
+    const r = await this.request("POST", "/v1/tts/session", {
+      max_characters: options.maxCharacters,
+      language: options.language
+    });
+    return {
+      sessionId: r.session_id,
+      token: r.token,
+      serverUrl: r.server_url,
+      expiresAt: r.expires_at
+    };
+  }
+  async extendTTSSession(options) {
+    const r = await this.request("POST", "/v1/tts/session/extend", {
+      session_id: options.sessionId,
+      additional_characters: options.additionalCharacters
+    });
+    return {
+      token: r.token,
+      maxCharacters: r.max_characters,
+      newExpiresAt: r.new_expires_at
+    };
+  }
+  // --- Internal: authenticated request ---
+  async request(method, path, body) {
+    const headers = await createAuthHeaders(this.account, method, path);
+    const init = {
+      method,
+      headers: {
+        ...headers,
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    };
+    const resp = await fetch(`${this.baseUrl}${path}`, init);
+    return this.handleResponse(resp, path);
+  }
+  // --- Internal: x402 payment request (for buyCredits) ---
+  async requestWithPayment(path, body) {
+    let resp;
+    try {
+      resp = await this.fetchWithPayment(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new PaymentError(
+        `Payment failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return this.handleResponse(resp, path);
+  }
+  // --- Internal: response handling ---
+  async handleResponse(resp, path) {
+    if (resp.ok) {
+      return await resp.json();
+    }
+    const text = await resp.text().catch(() => "");
+    let errorMessage;
+    try {
+      const parsed = JSON.parse(text);
+      errorMessage = parsed.error ?? text;
+    } catch {
+      errorMessage = text || resp.statusText;
+    }
+    switch (resp.status) {
+      case 402:
+        throw new InsufficientCreditsError(errorMessage);
+      case 429: {
+        if (errorMessage.toLowerCase().includes("concurrent")) {
+          throw new ConcurrencyLimitError(errorMessage);
+        }
+        throw new RateLimitError(errorMessage);
+      }
+      case 503: {
+        const service = path.split("/")[2] ?? "unknown";
+        throw new NoCapacityError(errorMessage, service);
+      }
+      default:
+        throw new GatewayError(errorMessage, resp.status);
+    }
+  }
+};
+function mapTransaction(r) {
+  return {
+    id: r.id,
+    amount: r.amount,
+    balanceAfter: r.balance_after,
+    type: r.type,
+    referenceId: r.reference_id,
+    service: r.service,
+    description: r.description,
+    createdAt: r.created_at
+  };
+}
+function mapSession(r) {
+  return {
+    id: r.id,
+    service: r.service,
+    bundleId: r.bundle_id,
+    status: r.status,
+    roomName: r.room_name,
+    serverUrl: r.server_url,
+    reservedMicrocredits: r.reserved_microcredits,
+    chargedMicrocredits: r.charged_microcredits,
+    tokenExpiresAt: r.token_expires_at,
+    startedAt: r.started_at,
+    endedAt: r.ended_at,
+    settlementMethod: r.settlement_method,
+    createdAt: r.created_at
+  };
+}
+export {
+  ConcurrencyLimitError,
+  DtelecomGateway,
+  GatewayError,
+  InsufficientCreditsError,
+  NoCapacityError,
+  PaymentError,
+  RateLimitError,
+  createAuthHeaders
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@dtelecom/x402-client",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for dTelecom x402 gateway — buy credits and create WebRTC/STT/TTS sessions",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "x402",
+    "webrtc",
+    "stt",
+    "tts",
+    "micropayments",
+    "dtelecom"
+  ],
+  "author": "dTelecom <dev@dtelecom.org>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dTelecom/x402-client.git"
+  },
+  "homepage": "https://github.com/dTelecom/x402-client#readme",
+  "dependencies": {
+    "@x402/evm": "^2.5.0",
+    "@x402/fetch": "^2.5.0",
+    "viem": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}