@unifold/core 0.1.68-beta.0 → 0.1.68-beta.2

package/dist/index.mjs

@@ -128,18 +128,15 @@ async function createDepositAddress(overrides, publishableKey) {
 async function getDepositAddress(params, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/deposit_addresses/existing`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(params)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/deposit_addresses/existing`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(params)
+  });
   if (!response.ok) {
     throw new Error(`Failed to get deposit addresses: ${response.statusText}`);
   }
@@ -165,18 +162,15 @@ async function queryExecutions(externalUserId, publishableKey, actionType = "dep
     external_user_id: externalUserId,
     action_type: actionType
   };
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/direct_executions/query`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/direct_executions/query`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
   if (!response.ok) {
     throw new Error(`Failed to query executions: ${response.statusText}`);
   }
@@ -185,18 +179,15 @@ async function queryExecutions(externalUserId, publishableKey, actionType = "dep
 async function pollDirectExecutions(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/direct_executions/poll`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/direct_executions/poll`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
     throw new Error(`Failed to poll direct executions: ${response.statusText}`);
   }
@@ -222,9 +213,7 @@ async function getSupportedDestinationTokens(publishableKey, options) {
     }
   });
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch supported destination tokens: ${response.statusText}`
-    );
+    throw new Error(`Failed to fetch supported destination tokens: ${response.statusText}`);
   }
   return response.json();
 }
@@ -253,9 +242,7 @@ async function getSupportedDepositTokens(publishableKey, options) {
     }
   });
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch supported deposit tokens: ${response.statusText}`
-    );
+    throw new Error(`Failed to fetch supported deposit tokens: ${response.statusText}`);
   }
   return response.json();
 }
@@ -267,16 +254,13 @@ async function getTokenMetadata(request, publishableKey) {
     chainId: request.chain_id,
     tokenAddress: request.token_address
   });
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/tokens/token?${params.toString()}`,
-    {
-      method: "GET",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk
-      }
+  const response = await fetch(`${API_BASE_URL}/v1/public/tokens/token?${params.toString()}`, {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk
     }
-  );
+  });
   if (!response.ok) {
     throw new Error(`Failed to fetch token metadata: ${response.statusText}`);
   }
@@ -295,16 +279,13 @@ function getPreferredIconUrl(iconUrls, preferredFormat = "svg") {
 async function getFiatCurrencies(publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/fiat_currencies`,
-    {
-      method: "GET",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk
-      }
+  const response = await fetch(`${API_BASE_URL}/v1/public/onramps/fiat_currencies`, {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk
     }
-  );
+  });
   if (!response.ok) {
     throw new Error(`Failed to fetch fiat currencies: ${response.statusText}`);
   }
@@ -313,18 +294,15 @@ async function getFiatCurrencies(publishableKey) {
 async function getOnrampQuotes(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/quotes`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/onramps/quotes`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
     throw new Error(`Failed to fetch onramp quotes: ${response.statusText}`);
   }
@@ -333,18 +311,15 @@ async function getOnrampQuotes(request, publishableKey) {
 async function createOnrampSession(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/sessions`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/onramps/sessions`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
     throw new Error(`Failed to create onramp session: ${response.statusText}`);
   }
@@ -367,9 +342,23 @@ async function getBankTransferProviders(publishableKey, options = {}) {
     }
   });
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch bank-transfer providers: ${response.statusText}`
-    );
+    throw new Error(`Failed to fetch bank-transfer providers: ${response.statusText}`);
+  }
+  return response.json();
+}
+async function getApplePayProviders(publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const url = `${API_BASE_URL}/v1/public/onramps/apple_pay/providers`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch Apple Pay providers: ${response.statusText}`);
   }
   return response.json();
 }
@@ -442,10 +431,18 @@ function getChainName(chains, chainType, chainId) {
   if (!chainType) return chainId || "Unknown";
   return chainType.charAt(0).toUpperCase() + chainType.slice(1);
 }
-async function getProjectConfig(publishableKey) {
+async function getProjectConfig(publishableKey, options) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const url = `${API_BASE_URL}/v1/public/projects/config`;
+  const params = new URLSearchParams();
+  if (options?.countryCode) {
+    params.set("country_code", options.countryCode);
+  }
+  if (options?.subdivisionCode) {
+    params.set("subdivision_code", options.subdivisionCode);
+  }
+  const queryString = params.toString();
+  const url = `${API_BASE_URL}/v1/public/projects/config${queryString ? `?${queryString}` : ""}`;
   const response = await fetch(url, {
     method: "GET",
     headers: {
@@ -467,9 +464,7 @@ async function getIpAddress() {
     }
   });
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch IP address information: ${response.statusText}`
-    );
+    throw new Error(`Failed to fetch IP address information: ${response.statusText}`);
   }
   return response.json();
 }
@@ -571,31 +566,24 @@ async function verifyRecipientAddress(request, publishableKey) {
     body: JSON.stringify(request)
   });
   if (!response.ok) {
-    throw new Error(
-      `Failed to verify recipient address: ${response.statusText}`
-    );
+    throw new Error(`Failed to verify recipient address: ${response.statusText}`);
   }
   return response.json();
 }
 async function checkHypercoreActivation(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/addresses/hypercore/activation`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/addresses/hypercore/activation`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
-    throw new Error(
-      `HyperCore activation check failed: ${response.statusText}`
-    );
+    throw new Error(`HyperCore activation check failed: ${response.statusText}`);
   }
   return response.json();
 }
@@ -603,7 +591,8 @@ async function getExchanges(query, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
   const params = new URLSearchParams();
-  if (query?.destination_currency) params.append("destination_currency", query.destination_currency);
+  if (query?.destination_currency)
+    params.append("destination_currency", query.destination_currency);
   if (query?.destination_network) params.append("destination_network", query.destination_network);
   const queryString = params.toString();
   const url = `${API_BASE_URL}/v1/public/onramps/exchanges${queryString ? `?${queryString}` : ""}`;
@@ -623,18 +612,15 @@ async function getExchanges(query, publishableKey) {
 async function createExchangeSession(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/exchanges/sessions`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/onramps/exchanges/sessions`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
     throw new Error(`Failed to create exchange session: ${response.statusText}`);
   }
@@ -787,15 +773,18 @@ async function confirmIntegrationTransfer(transferId, accessToken, mfaCode, publ
   validatePublishableKey(pk);
   const body = { access_token: accessToken };
   if (mfaCode) body.mfa_code = mfaCode;
-  const response = await fetch(`${API_BASE_URL}/v1/public/integrations/transfers/${transferId}/confirm`, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      "x-publishable-key": pk,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  });
+  const response = await fetch(
+    `${API_BASE_URL}/v1/public/integrations/transfers/${transferId}/confirm`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    }
+  );
   if (!response.ok) {
     const err = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(`Failed to confirm transfer: ${err.message || response.statusText}`);
@@ -834,9 +823,7 @@ async function buildSolanaTransaction(request, publishableKey) {
   });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(
-      `Failed to build Solana transaction: ${error.message || response.statusText}`
-    );
+    throw new Error(`Failed to build Solana transaction: ${error.message || response.statusText}`);
   }
   return response.json();
 }
@@ -854,50 +841,40 @@ async function sendSolanaTransaction(request, publishableKey) {
   });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(
-      `Failed to send Solana transaction: ${error.message || response.statusText}`
-    );
+    throw new Error(`Failed to send Solana transaction: ${error.message || response.statusText}`);
   }
   return response.json();
 }
 async function retrievePaymentIntent(clientSecret, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/payment_intents/retrieve`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ client_secret: clientSecret })
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/payment_intents/retrieve`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ client_secret: clientSecret })
+  });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(
-      `Failed to retrieve payment intent: ${error.message || response.statusText}`
-    );
+    throw new Error(`Failed to retrieve payment intent: ${error.message || response.statusText}`);
   }
   return response.json();
 }
 async function listPaymentIntentExecutions(clientSecret, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/payment_intents/executions`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ client_secret: clientSecret })
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/payment_intents/executions`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ client_secret: clientSecret })
+  });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(
@@ -920,9 +897,7 @@ async function getDepositQuote(request, publishableKey) {
   });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(
-      `Failed to get deposit quote: ${error.message || response.statusText}`
-    );
+    throw new Error(`Failed to get deposit quote: ${error.message || response.statusText}`);
   }
   const json = await response.json();
   return json.data;
@@ -930,18 +905,15 @@ async function getDepositQuote(request, publishableKey) {
 async function buildHypercoreTransaction(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(
-    `${API_BASE_URL}/v1/public/transactions/hypercore/build`,
-    {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    }
-  );
+  const response = await fetch(`${API_BASE_URL}/v1/public/transactions/hypercore/build`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(
@@ -965,40 +937,60 @@ async function getCashAppLimits(currency = "usd", publishableKey) {
   );
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(
-      `Failed to get Cash App limits: ${error.message || response.statusText}`
-    );
+    throw new Error(`Failed to get Cash App limits: ${error.message || response.statusText}`);
   }
   return response.json();
 }
 async function createCashAppSession(request, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}/v1/public/onramps/cashapp/sessions`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throw new Error(`Failed to create Cash App session: ${error.message || response.statusText}`);
+  }
+  return response.json();
+}
+async function getCashAppSessionStatus(externalId, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
   const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/cashapp/sessions`,
+    `${API_BASE_URL}/v1/public/onramps/cashapp/sessions/${encodeURIComponent(externalId)}/status`,
     {
-      method: "POST",
+      method: "GET",
       headers: {
         accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
+        "x-publishable-key": pk
+      }
     }
   );
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(
-      `Failed to create Cash App session: ${error.message || response.statusText}`
+      `Failed to get Cash App session status: ${error.message || response.statusText}`
     );
   }
   return response.json();
 }
-async function getCashAppSessionStatus(externalId, publishableKey) {
+async function stripeGetDefaultToken(params, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
+  const query = new URLSearchParams({
+    token_address: params.tokenAddress,
+    chain_id: params.chainId,
+    chain_type: params.chainType
+  });
+  if (params.countryCode) query.append("country_code", params.countryCode);
   const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/cashapp/sessions/${encodeURIComponent(externalId)}/status`,
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/default_token?${query.toString()}`,
     {
       method: "GET",
       headers: {
@@ -1007,29 +999,317 @@ async function getCashAppSessionStatus(externalId, publishableKey) {
       }
     }
   );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to get Stripe default token", response, error);
+  }
+  return response.json();
+}
+var HEADLESS_STRIPE_BASE = "/v1/public/onramps/headless/stripe";
+var StripeApiResponseError = class extends Error {
+  constructor(message, statusCode, stripeCode, errorType) {
+    super(message);
+    this.statusCode = statusCode;
+    this.stripeCode = stripeCode;
+    this.errorType = errorType;
+    this.name = "StripeApiResponseError";
+  }
+};
+function throwStripeError(prefix, response, error) {
+  const stripeError = error.details?.stripe_error;
+  const detailMessage = stripeError?.message || error.message || response.statusText;
+  throw new StripeApiResponseError(
+    `${prefix}: ${detailMessage}`,
+    response.status,
+    stripeError?.code,
+    error.error_type
+  );
+}
+async function stripeGetConfig(publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}${HEADLESS_STRIPE_BASE}/config`, {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to get Stripe config", response, error);
+  }
+  return response.json();
+}
+async function stripeCreateAuthIntent(email, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}${HEADLESS_STRIPE_BASE}/oauth/start`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ email })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to create Stripe auth intent", response, error);
+  }
+  return response.json();
+}
+async function stripeExchangeTokens(authIntentId, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}${HEADLESS_STRIPE_BASE}/oauth/token`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ auth_intent_id: authIntentId })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to exchange Stripe tokens", response, error);
+  }
+  return response.json();
+}
+async function stripeRefreshToken(refreshToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}${HEADLESS_STRIPE_BASE}/oauth/token/refresh`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ refresh_token: refreshToken })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to refresh Stripe token", response, error);
+  }
+  return response.json();
+}
+async function stripeGetCustomer(customerId, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/customers/${encodeURIComponent(customerId)}`,
+    {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to get Stripe customer", response, error);
+  }
+  return response.json();
+}
+async function stripeListWallets(customerId, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/customers/${encodeURIComponent(customerId)}/wallet_addresses`,
+    {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to list Stripe wallets", response, error);
+  }
+  return response.json();
+}
+async function stripeListPaymentTokens(customerId, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/customers/${encodeURIComponent(customerId)}/payment_tokens`,
+    {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken
+      }
+    }
+  );
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(
-      `Failed to get Cash App session status: ${error.message || response.statusText}`
+      `Failed to list Stripe payment tokens: ${error.message || response.statusText}`
     );
   }
   return response.json();
 }
-async function sendHypercoreTransaction(request, publishableKey) {
+async function stripeCreateSession(request, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}${HEADLESS_STRIPE_BASE}/sessions`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "x-stripe-oauth-token": oauthToken,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      crypto_customer_id: request.cryptoCustomerId,
+      payment_token: request.paymentToken,
+      source_amount: request.sourceAmount,
+      source_currency: request.sourceCurrency,
+      destination_currency: request.destinationCurrency,
+      destination_network: request.destinationNetwork,
+      wallet_address: request.walletAddress
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to create Stripe session", response, error);
+  }
+  return response.json();
+}
+async function stripeConfirmSession(sessionId, oauthToken, request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
   const response = await fetch(
-    `${API_BASE_URL}/v1/public/transactions/hypercore/send`,
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/sessions/${encodeURIComponent(sessionId)}/confirm`,
     {
       method: "POST",
       headers: {
         accept: "application/json",
         "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(request)
+      body: JSON.stringify(request?.mandateData ? { mandate_data: request.mandateData } : {})
     }
   );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to confirm Stripe session", response, error);
+  }
+  return response.json();
+}
+async function stripeRefreshQuote(sessionId, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/sessions/${encodeURIComponent(sessionId)}/quote/refresh`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to refresh Stripe quote", response, error);
+  }
+  return response.json();
+}
+async function stripeGetSession(sessionId, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/sessions/${encodeURIComponent(sessionId)}`,
+    {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to get Stripe session", response, error);
+  }
+  return response.json();
+}
+async function stripeGetQuotes(request, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const headers = {
+    accept: "application/json",
+    "x-publishable-key": pk,
+    "Content-Type": "application/json"
+  };
+  if (oauthToken) headers["x-stripe-oauth-token"] = oauthToken;
+  const response = await fetch(`${API_BASE_URL}${HEADLESS_STRIPE_BASE}/quotes`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      source_amount: request.sourceAmount,
+      source_currency: request.sourceCurrency,
+      destination_currency: request.destinationCurrency,
+      destination_network: request.destinationNetwork
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to get Stripe quotes", response, error);
+  }
+  return response.json();
+}
+async function stripeGetTransactionLimits(params, oauthToken, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const query = new URLSearchParams({
+    crypto_customer_id: params.cryptoCustomerId,
+    destination_network: params.destinationNetwork,
+    wallet_address: params.walletAddress
+  });
+  if (params.destinationTag) query.append("destination_tag", params.destinationTag);
+  if (params.refresh) query.append("refresh", "true");
+  const response = await fetch(
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/transaction_limits?${query.toString()}`,
+    {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "x-stripe-oauth-token": oauthToken
+      }
+    }
+  );
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throwStripeError("Failed to get Stripe transaction limits", response, error);
+  }
+  return response.json();
+}
+async function sendHypercoreTransaction(request, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}/v1/public/transactions/hypercore/send`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(
@@ -1038,6 +1318,186 @@ async function sendHypercoreTransaction(request, publishableKey) {
   }
   return response.json();
 }
+async function getCoinbaseLegalAgreements(publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}/v1/public/onramps/headless/coinbase/legal_agreements`,
+    {
+      method: "GET",
+      headers: { accept: "application/json", "x-publishable-key": pk }
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to fetch Coinbase legal agreements: ${response.statusText}`);
+  }
+  return response.json();
+}
+var VERIFICATION_BASE = "/v1/public/onramps/verification_sessions";
+async function jsonOrThrow(response, label) {
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    const body = error;
+    const tag = body.error_type ? ` [${body.error_type}]` : "";
+    throw new Error(`${label}${tag}: ${body.message || response.statusText}`);
+  }
+  return response.json();
+}
+async function createOnrampVerificationSession(request, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}${VERIFICATION_BASE}`, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request)
+  });
+  return jsonOrThrow(response, "Failed to create verification session");
+}
+async function postVerificationAction(id, factor, action, body, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${VERIFICATION_BASE}/${encodeURIComponent(id)}/${factor}/${action}`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    }
+  );
+  return jsonOrThrow(response, `Failed to ${action} ${factor} OTP`);
+}
+async function sendOnrampVerificationOtp(id, factor, clientSecret, publishableKey) {
+  return postVerificationAction(
+    id,
+    factor,
+    "send",
+    { client_secret: clientSecret },
+    publishableKey
+  );
+}
+async function verifyOnrampVerificationOtp(id, factor, clientSecret, code, publishableKey) {
+  return postVerificationAction(
+    id,
+    factor,
+    "verify",
+    { client_secret: clientSecret, code },
+    publishableKey
+  );
+}
+async function exchangeOnrampVerificationToken(id, clientSecret, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}${VERIFICATION_BASE}/${encodeURIComponent(id)}/token`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ client_secret: clientSecret })
+    }
+  );
+  return jsonOrThrow(
+    response,
+    "Failed to exchange verification token"
+  );
+}
+async function getOnrampVerificationSession(id, clientSecret, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const url = new URL(`${API_BASE_URL}${VERIFICATION_BASE}/${encodeURIComponent(id)}`);
+  url.searchParams.set("client_secret", clientSecret);
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: { accept: "application/json", "x-publishable-key": pk }
+  });
+  return jsonOrThrow(response, "Failed to fetch verification session");
+}
+function isApplePayLimitReached(response) {
+  return response.limits.some((l) => l.remaining === "0");
+}
+function getApplePayLimitUpgradeStatus(response) {
+  const opt = response.limit_upgrade_options?.[0];
+  if (!opt || typeof opt.status !== "string") return null;
+  return opt.status;
+}
+async function getCoinbaseApplePayLimits(phone, publishableKey, signal) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}/v1/public/onramps/headless/coinbase/apple_pay/limits`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ phone }),
+      signal
+    }
+  );
+  const raw = await jsonOrThrow(response, "Failed to fetch Apple Pay limits");
+  return {
+    limits: raw.limits,
+    limit_upgrade_options: raw.limit_upgrade_options,
+    limit_reached: isApplePayLimitReached(raw),
+    upgrade_status: getApplePayLimitUpgradeStatus(raw)
+  };
+}
+async function requestCoinbaseApplePayLimitUpgrade(request, publishableKey, signal) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}/v1/public/onramps/headless/coinbase/apple_pay/limits/upgrade`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request),
+      signal
+    }
+  );
+  return jsonOrThrow(
+    response,
+    "Failed to request Apple Pay limit upgrade"
+  );
+}
+async function createCoinbaseApplePaySession(request, onrampToken, publishableKey, signal) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(
+    `${API_BASE_URL}/v1/public/onramps/headless/coinbase/apple_pay/sessions`,
+    {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "x-publishable-key": pk,
+        "Content-Type": "application/json",
+        "x-onramp-token": onrampToken
+      },
+      body: JSON.stringify(request),
+      signal
+    }
+  );
+  return jsonOrThrow(
+    response,
+    "Failed to create Apple Pay session"
+  );
+}
 
 // src/lib/events.ts
 var DepositEventType = /* @__PURE__ */ ((DepositEventType2) => {
@@ -1193,6 +1653,7 @@ export {
   IneligibilityReason,
   IntegrationProvider,
   SOLANA_USDC_ADDRESS,
+  StripeApiResponseError,
   WithdrawEventType,
   authenticateIntegrationOAuth,
   buildHypercoreTransaction,
@@ -1200,20 +1661,27 @@ export {
   checkHypercoreActivation,
   confirmIntegrationTransfer,
   createCashAppSession,
+  createCoinbaseApplePaySession,
   createDepositAddress,
   createExchangeSession,
   createIntegrationTransfer,
   createOnrampSession,
+  createOnrampVerificationSession,
+  exchangeOnrampVerificationToken,
   formatStablecoinAmount,
   generateKSUID,
   generatePrefixedKSUID,
   getAddressBalance,
   getAddressBalances,
   getApiBaseUrl,
+  getApplePayLimitUpgradeStatus,
+  getApplePayProviders,
   getBankTransferProviders,
   getCashAppLimits,
   getCashAppSessionStatus,
   getChainName,
+  getCoinbaseApplePayLimits,
+  getCoinbaseLegalAgreements,
   getDefaultOnrampToken,
   getDepositAddress,
   getDepositQuote,
@@ -1229,6 +1697,7 @@ export {
   getIpAddress,
   getOnrampQuotes,
   getOnrampSessionStartUrl,
+  getOnrampVerificationSession,
   getPreferredIconUrl,
   getProjectConfig,
   getSupportedDepositTokens,
@@ -1238,16 +1707,34 @@ export {
   getWalletByChainType,
   getWalletMobileDeepLink,
   i18n,
+  isApplePayLimitReached,
   listPaymentIntentExecutions,
   pollDirectExecutions,
   queryExecutions,
   refreshIntegrationToken,
+  requestCoinbaseApplePayLimitUpgrade,
   retrievePaymentIntent,
   revokeIntegrationToken,
   sendHypercoreTransaction,
+  sendOnrampVerificationOtp,
   sendSolanaTransaction,
   setApiConfig,
   startIntegrationOAuth,
+  stripeConfirmSession,
+  stripeCreateAuthIntent,
+  stripeCreateSession,
+  stripeExchangeTokens,
+  stripeGetConfig,
+  stripeGetCustomer,
+  stripeGetDefaultToken,
+  stripeGetQuotes,
+  stripeGetSession,
+  stripeGetTransactionLimits,
+  stripeListPaymentTokens,
+  stripeListWallets,
+  stripeRefreshQuote,
+  stripeRefreshToken,
   useUserIp,
+  verifyOnrampVerificationOtp,
   verifyRecipientAddress
 };