@coinbase/cdp-api-client 0.0.54 → 0.0.56

package/dist/esm/index7.js

@@ -0,0 +1,179 @@
+import h from "axios";
+import { ERROR_DOCS_PAGE_URL as d } from "./index9.js";
+import { UnknownApiError as w, HttpErrorType as i, isOpenAPIError as m, APIError as u, UnknownError as v } from "./index8.js";
+const y = () => typeof window < "u" && typeof document < "u";
+let a = h.create({
+  baseURL: "https://api.cdp.coinbase.com/platform"
+}), n = null;
+const x = (r) => {
+  a = h.create({
+    baseURL: r.basePath || "https://api.cdp.coinbase.com/platform",
+    // Only enable cookies in browser environments where they're supported
+    withCredentials: y()
+  }), a.interceptors.request.use(async (e) => {
+    const t = E(e), s = c(e);
+    if (!n || l(s.pathname) || p(s.pathname) && !await n.isSignedIn())
+      return e;
+    const o = await n.getXWalletAuth({
+      requestMethod: t,
+      requestHost: s.host,
+      requestPath: s.pathname,
+      requestData: e.data
+    });
+    return o && (e.headers["X-Wallet-Auth"] = o), e;
+  }), a.interceptors.request.use(async (e) => {
+    const t = c(e);
+    if (!n || l(t.pathname) || p(t.pathname) && !await n.isSignedIn())
+      return e;
+    const s = await n.getToken();
+    return s && s !== "" && (e.headers.Authorization = `Bearer ${s}`), e;
+  }), r.refreshTokenStorage && A(r.refreshTokenStorage), r.debugging && (a.interceptors.request.use((e) => (console.log("Request:", e), e)), a.interceptors.response.use((e) => (console.log("Response:", e), e)));
+}, C = (r) => {
+  n = r;
+}, R = (r, e) => ({
+  ...r,
+  headers: {
+    ...r.headers || {},
+    "X-Idempotency-Key": e
+  }
+}), $ = async (r, e) => {
+  g(r), e && e !== "" && (r = R(r, e));
+  try {
+    return (await a(r)).data;
+  } catch (t) {
+    if (h.isAxiosError(t) && !t.response)
+      throw new w(
+        i.unknown,
+        t.cause instanceof Error ? t.cause.message : t.message,
+        t.cause
+      );
+    if (h.isAxiosError(t) && t.response) {
+      if (m(t.response.data))
+        throw new u(
+          t.response.status,
+          t.response.data.errorType,
+          t.response.data.errorMessage,
+          t.response.data.correlationId,
+          t.response.data.errorLink,
+          t.cause
+        );
+      {
+        const s = t.response.status;
+        switch (s) {
+          case 401:
+            throw new u(
+              s,
+              i.unauthorized,
+              "Unauthorized.",
+              void 0,
+              `${d}#unauthorized`,
+              t.cause
+            );
+          case 404:
+            throw new u(
+              s,
+              i.not_found,
+              "API not found.",
+              void 0,
+              `${d}#not_found`,
+              t.cause
+            );
+          case 502:
+            throw new u(
+              s,
+              i.bad_gateway,
+              "Bad gateway.",
+              void 0,
+              `${d}`,
+              t.cause
+            );
+          case 503:
+            throw new u(
+              s,
+              i.service_unavailable,
+              "Service unavailable. Please try again later.",
+              void 0,
+              `${d}`,
+              t.cause
+            );
+          default: {
+            let o = "";
+            if (t.response.data)
+              try {
+                o = JSON.stringify(t.response.data);
+              } catch {
+                o = String(t.response.data);
+              }
+            const f = o ? `An unexpected error occurred: ${o}` : "An unexpected error occurred.";
+            throw new u(
+              s,
+              i.unexpected_error,
+              f,
+              void 0,
+              `${d}`,
+              t.cause
+            );
+          }
+        }
+      }
+    }
+    throw new v(
+      "Something went wrong. Please reach out at https://discord.com/channels/1220414409550336183/1271495764580896789 for help.",
+      t instanceof Error ? t : void 0
+    );
+  }
+}, A = (r) => {
+  a.interceptors.response.use(
+    async (e) => {
+      try {
+        if (U(e)) {
+          const t = e.data?.refreshToken;
+          t && await r.setRefreshToken(t);
+        }
+      } catch (t) {
+        console.warn("Failed to store refresh token:", t);
+      }
+      return e;
+    },
+    (e) => Promise.reject(e)
+  ), a.interceptors.request.use(async (e) => {
+    try {
+      if (T(e.url)) {
+        const t = await r.getRefreshToken();
+        t && (e.data = {
+          ...e.data,
+          refreshToken: t
+        });
+      }
+      k(e.url) && await r.removeRefreshToken();
+    } catch (t) {
+      console.warn("Failed to retrieve refresh token:", t);
+    }
+    return e;
+  });
+}, k = (r) => r ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/logout$/.test(r) : !1, T = (r) => r ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(refresh|logout)$/.test(r) : !1, U = (r) => {
+  const e = r.config.url;
+  return e ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(verify\/(email|sms|oauth\/.*)|refresh)$/.test(
+    e
+  ) : !1;
+}, g = (r) => {
+  if (!a.getUri() || a.getUri() === "")
+    throw new Error("CDP client URI not configured. Call configure() first.");
+  if (!r.url || r.url === "")
+    throw new Error("AxiosRequestConfig URL is empty. This should never happen.");
+  if (!r.method || r.method === "")
+    throw new Error("AxiosRequestConfig method is empty. This should never happen.");
+}, E = (r) => r.method?.toString().toUpperCase() || "GET", c = (r) => {
+  if (!r.url)
+    throw new Error("URL is required for authentication");
+  const e = a.getUri() + r.url;
+  return new URL(e);
+}, l = (r) => /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(refresh|logout)$/.test(r), p = (r) => {
+  const e = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(init)$/, t = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/verify\//;
+  return e.test(r) || t.test(r);
+};
+export {
+  $ as cdpApiClient,
+  x as configureCdpApiClient,
+  C as setAuthManager
+};

package/dist/esm/index8.js

@@ -0,0 +1,76 @@
+const u = {
+  unexpected_error: "unexpected_error",
+  unauthorized: "unauthorized",
+  not_found: "not_found",
+  bad_gateway: "bad_gateway",
+  service_unavailable: "service_unavailable",
+  unknown: "unknown"
+};
+class a extends Error {
+  statusCode;
+  errorType;
+  errorMessage;
+  correlationId;
+  errorLink;
+  /**
+   * Constructor for the APIError class
+   *
+   * @param statusCode - The HTTP status code
+   * @param errorType - The type of error
+   * @param errorMessage - The error message
+   * @param correlationId - The correlation ID
+   * @param errorLink - URL to documentation about this error
+   * @param cause - The cause of the error
+   */
+  constructor(e, o, t, n, s, i) {
+    super(t, { cause: i }), this.name = "APIError", this.statusCode = e, this.errorType = o, this.errorMessage = t, n !== void 0 && (this.correlationId = n), s !== void 0 && (this.errorLink = s);
+  }
+  /**
+   * Convert the error to a JSON object, excluding undefined properties
+   *
+   * @returns The error as a JSON object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      statusCode: this.statusCode,
+      errorType: this.errorType,
+      errorMessage: this.errorMessage,
+      ...this.correlationId && { correlationId: this.correlationId },
+      ...this.errorLink && { errorLink: this.errorLink }
+    };
+  }
+}
+class d extends a {
+  /**
+   * Constructor for the UnknownApiError class
+   *
+   * @param errorType - The type of error
+   * @param errorMessage - The error message
+   * @param cause - The cause of the error
+   */
+  constructor(e, o, t) {
+    super(0, e, o, void 0, void 0, t), this.name = "UnknownApiError";
+  }
+}
+class c extends Error {
+  /**
+   * Constructor for the UnknownError class
+   *
+   * @param message - The error message
+   * @param cause - The cause of the error
+   */
+  constructor(e, o) {
+    super(e, { cause: o }), this.name = "UnknownError";
+  }
+}
+function p(r) {
+  return r !== null && typeof r == "object" && "errorType" in r && typeof r.errorType == "string" && "errorMessage" in r && typeof r.errorMessage == "string";
+}
+export {
+  a as APIError,
+  u as HttpErrorType,
+  d as UnknownApiError,
+  c as UnknownError,
+  p as isOpenAPIError
+};

package/dist/esm/index9.js

@@ -0,0 +1,4 @@
+const o = "https://docs.cdp.coinbase.com/api-v2/docs/errors";
+export {
+  o as ERROR_DOCS_PAGE_URL
+};

package/dist/types/index.d.ts

@@ -1253,6 +1253,7 @@ export declare type OAuth2ProviderType = (typeof OAuth2ProviderType)[keyof typeo
 export declare const OAuth2ProviderType: {
     readonly google: "google";
     readonly apple: "apple";
+    readonly x: "x";
 };
 
 export declare interface OnchainAddress {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-api-client",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "type": "module",
   "files": [
     "dist/**",