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

package/dist/index.js

@@ -27,6 +27,7 @@ __export(index_exports, {
   IneligibilityReason: () => IneligibilityReason,
   IntegrationProvider: () => IntegrationProvider,
   SOLANA_USDC_ADDRESS: () => SOLANA_USDC_ADDRESS,
+  StripeApiResponseError: () => StripeApiResponseError,
   WithdrawEventType: () => WithdrawEventType,
   authenticateIntegrationOAuth: () => authenticateIntegrationOAuth,
   buildHypercoreTransaction: () => buildHypercoreTransaction,
@@ -34,20 +35,27 @@ __export(index_exports, {
   checkHypercoreActivation: () => checkHypercoreActivation,
   confirmIntegrationTransfer: () => confirmIntegrationTransfer,
   createCashAppSession: () => createCashAppSession,
+  createCoinbaseApplePaySession: () => createCoinbaseApplePaySession,
   createDepositAddress: () => createDepositAddress,
   createExchangeSession: () => createExchangeSession,
   createIntegrationTransfer: () => createIntegrationTransfer,
   createOnrampSession: () => createOnrampSession,
+  createOnrampVerificationSession: () => createOnrampVerificationSession,
+  exchangeOnrampVerificationToken: () => exchangeOnrampVerificationToken,
   formatStablecoinAmount: () => formatStablecoinAmount,
   generateKSUID: () => generateKSUID,
   generatePrefixedKSUID: () => generatePrefixedKSUID,
   getAddressBalance: () => getAddressBalance,
   getAddressBalances: () => getAddressBalances,
   getApiBaseUrl: () => getApiBaseUrl,
+  getApplePayLimitUpgradeStatus: () => getApplePayLimitUpgradeStatus,
+  getApplePayProviders: () => getApplePayProviders,
   getBankTransferProviders: () => getBankTransferProviders,
   getCashAppLimits: () => getCashAppLimits,
   getCashAppSessionStatus: () => getCashAppSessionStatus,
   getChainName: () => getChainName,
+  getCoinbaseApplePayLimits: () => getCoinbaseApplePayLimits,
+  getCoinbaseLegalAgreements: () => getCoinbaseLegalAgreements,
   getDefaultOnrampToken: () => getDefaultOnrampToken,
   getDepositAddress: () => getDepositAddress,
   getDepositQuote: () => getDepositQuote,
@@ -63,6 +71,7 @@ __export(index_exports, {
   getIpAddress: () => getIpAddress,
   getOnrampQuotes: () => getOnrampQuotes,
   getOnrampSessionStartUrl: () => getOnrampSessionStartUrl,
+  getOnrampVerificationSession: () => getOnrampVerificationSession,
   getPreferredIconUrl: () => getPreferredIconUrl,
   getProjectConfig: () => getProjectConfig,
   getSupportedDepositTokens: () => getSupportedDepositTokens,
@@ -72,17 +81,35 @@ __export(index_exports, {
   getWalletByChainType: () => getWalletByChainType,
   getWalletMobileDeepLink: () => getWalletMobileDeepLink,
   i18n: () => i18n,
+  isApplePayLimitReached: () => isApplePayLimitReached,
   listPaymentIntentExecutions: () => listPaymentIntentExecutions,
   pollDirectExecutions: () => pollDirectExecutions,
   queryExecutions: () => queryExecutions,
   refreshIntegrationToken: () => refreshIntegrationToken,
+  requestCoinbaseApplePayLimitUpgrade: () => requestCoinbaseApplePayLimitUpgrade,
   retrievePaymentIntent: () => retrievePaymentIntent,
   revokeIntegrationToken: () => revokeIntegrationToken,
   sendHypercoreTransaction: () => sendHypercoreTransaction,
+  sendOnrampVerificationOtp: () => sendOnrampVerificationOtp,
   sendSolanaTransaction: () => sendSolanaTransaction,
   setApiConfig: () => setApiConfig,
   startIntegrationOAuth: () => startIntegrationOAuth,
+  stripeConfirmSession: () => stripeConfirmSession,
+  stripeCreateAuthIntent: () => stripeCreateAuthIntent,
+  stripeCreateSession: () => stripeCreateSession,
+  stripeExchangeTokens: () => stripeExchangeTokens,
+  stripeGetConfig: () => stripeGetConfig,
+  stripeGetCustomer: () => stripeGetCustomer,
+  stripeGetDefaultToken: () => stripeGetDefaultToken,
+  stripeGetQuotes: () => stripeGetQuotes,
+  stripeGetSession: () => stripeGetSession,
+  stripeGetTransactionLimits: () => stripeGetTransactionLimits,
+  stripeListPaymentTokens: () => stripeListPaymentTokens,
+  stripeListWallets: () => stripeListWallets,
+  stripeRefreshQuote: () => stripeRefreshQuote,
+  stripeRefreshToken: () => stripeRefreshToken,
   useUserIp: () => useUserIp,
+  verifyOnrampVerificationOtp: () => verifyOnrampVerificationOtp,
   verifyRecipientAddress: () => verifyRecipientAddress
 });
 module.exports = __toCommonJS(index_exports);
@@ -217,18 +244,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}`);
   }
@@ -254,18 +278,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}`);
   }
@@ -274,18 +295,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}`);
   }
@@ -311,9 +329,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();
 }
@@ -342,9 +358,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();
 }
@@ -356,16 +370,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}`);
   }
@@ -384,16 +395,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}`);
   }
@@ -402,18 +410,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}`);
   }
@@ -422,18 +427,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}`);
   }
@@ -456,9 +458,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();
 }
@@ -531,10 +547,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: {
@@ -556,9 +580,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();
 }
@@ -660,31 +682,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();
 }
@@ -692,7 +707,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}` : ""}`;
@@ -712,18 +728,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}`);
   }
@@ -876,15 +889,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}`);
@@ -923,9 +939,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();
 }
@@ -943,50 +957,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(
@@ -1009,9 +1013,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;
@@ -1019,18 +1021,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(
@@ -1054,40 +1053,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: {
@@ -1096,29 +1115,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(
@@ -1127,6 +1434,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) => {
@@ -1283,6 +1770,7 @@ var i18n = en_default;
   IneligibilityReason,
   IntegrationProvider,
   SOLANA_USDC_ADDRESS,
+  StripeApiResponseError,
   WithdrawEventType,
   authenticateIntegrationOAuth,
   buildHypercoreTransaction,
@@ -1290,20 +1778,27 @@ var i18n = en_default;
   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,
@@ -1319,6 +1814,7 @@ var i18n = en_default;
   getIpAddress,
   getOnrampQuotes,
   getOnrampSessionStartUrl,
+  getOnrampVerificationSession,
   getPreferredIconUrl,
   getProjectConfig,
   getSupportedDepositTokens,
@@ -1328,16 +1824,34 @@ var i18n = en_default;
   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
 });