@unifold/core 0.1.67 → 0.1.68-beta.1

package/dist/index.js

@@ -21,11 +21,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ActionType: () => ActionType,
+  CheckoutEventType: () => CheckoutEventType,
   DepositEventType: () => DepositEventType,
   ExecutionStatus: () => ExecutionStatus,
   IneligibilityReason: () => IneligibilityReason,
   IntegrationProvider: () => IntegrationProvider,
   SOLANA_USDC_ADDRESS: () => SOLANA_USDC_ADDRESS,
+  StripeApiResponseError: () => StripeApiResponseError,
   WithdrawEventType: () => WithdrawEventType,
   authenticateIntegrationOAuth: () => authenticateIntegrationOAuth,
   buildHypercoreTransaction: () => buildHypercoreTransaction,
@@ -33,19 +35,25 @@ __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,
+  getApplePayProviders: () => getApplePayProviders,
+  getBankTransferProviders: () => getBankTransferProviders,
   getCashAppLimits: () => getCashAppLimits,
   getCashAppSessionStatus: () => getCashAppSessionStatus,
   getChainName: () => getChainName,
+  getCoinbaseLegalAgreements: () => getCoinbaseLegalAgreements,
   getDefaultOnrampToken: () => getDefaultOnrampToken,
   getDepositAddress: () => getDepositAddress,
   getDepositQuote: () => getDepositQuote,
@@ -61,6 +69,7 @@ __export(index_exports, {
   getIpAddress: () => getIpAddress,
   getOnrampQuotes: () => getOnrampQuotes,
   getOnrampSessionStartUrl: () => getOnrampSessionStartUrl,
+  getOnrampVerificationSession: () => getOnrampVerificationSession,
   getPreferredIconUrl: () => getPreferredIconUrl,
   getProjectConfig: () => getProjectConfig,
   getSupportedDepositTokens: () => getSupportedDepositTokens,
@@ -77,10 +86,26 @@ __export(index_exports, {
   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);
@@ -215,18 +240,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}`);
   }
@@ -252,18 +274,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}`);
   }
@@ -272,18 +291,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}`);
   }
@@ -309,9 +325,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();
 }
@@ -340,9 +354,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();
 }
@@ -354,16 +366,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}`);
   }
@@ -382,16 +391,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}`);
   }
@@ -400,18 +406,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}`);
   }
@@ -420,23 +423,57 @@ 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}`);
   }
   return response.json();
 }
+async function getBankTransferProviders(publishableKey, options = {}) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const params = new URLSearchParams();
+  if (options.countryCode) {
+    params.set("country_code", options.countryCode);
+  }
+  const queryString = params.toString();
+  const url = `${API_BASE_URL}/v1/public/onramps/bank_transfer/providers${queryString ? `?${queryString}` : ""}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      "x-publishable-key": pk
+    }
+  });
+  if (!response.ok) {
+    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();
+}
 function getOnrampSessionStartUrl(request, publishableKey) {
   const params = new URLSearchParams();
   params.append("publishable_key", publishableKey);
@@ -454,6 +491,9 @@ function getOnrampSessionStartUrl(request, publishableKey) {
   if (request.email) {
     params.append("email", request.email);
   }
+  if (request.payment_method) {
+    params.append("payment_method", request.payment_method);
+  }
   return `${API_BASE_URL}/v1/public/onramps/sessions/start?${params.toString()}`;
 }
 async function getDefaultOnrampToken(params, publishableKey) {
@@ -503,10 +543,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: {
@@ -528,9 +576,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();
 }
@@ -632,31 +678,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();
 }
@@ -664,7 +703,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}` : ""}`;
@@ -684,18 +724,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}`);
   }
@@ -848,15 +885,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}`);
@@ -895,9 +935,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();
 }
@@ -915,62 +953,110 @@ 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}`);
+  }
+  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 })
+  });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
     throw new Error(
-      `Failed to retrieve payment intent: ${error.message || response.statusText}`
+      `Failed to list payment intent executions: ${error.message || response.statusText}`
     );
   }
   return response.json();
 }
-async function listPaymentIntentExecutions(clientSecret, publishableKey) {
+async function getDepositQuote(request, publishableKey) {
+  const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
+  validatePublishableKey(pk);
+  const response = await fetch(`${API_BASE_URL}/v1/public/quotes`, {
+    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 get deposit quote: ${error.message || response.statusText}`);
+  }
+  const json = await response.json();
+  return json.data;
+}
+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)
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: response.statusText }));
+    throw new Error(
+      `Failed to build HyperCore transaction: ${error.message || response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function getCashAppLimits(currency = "usd", publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
   const response = await fetch(
-    `${API_BASE_URL}/v1/public/payment_intents/executions`,
+    `${API_BASE_URL}/v1/public/onramps/cashapp/limits?currency=${encodeURIComponent(currency)}`,
     {
-      method: "POST",
+      method: "GET",
       headers: {
         accept: "application/json",
-        "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ client_secret: clientSecret })
+        "x-publishable-key": pk
+      }
     }
   );
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(
-      `Failed to list payment intent executions: ${error.message || response.statusText}`
-    );
+    throw new Error(`Failed to get Cash App limits: ${error.message || response.statusText}`);
   }
   return response.json();
 }
-async function getDepositQuote(request, publishableKey) {
+async function createCashAppSession(request, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
-  const response = await fetch(`${API_BASE_URL}/v1/public/quotes`, {
+  const response = await fetch(`${API_BASE_URL}/v1/public/onramps/cashapp/sessions`, {
     method: "POST",
     headers: {
       accept: "application/json",
@@ -981,41 +1067,42 @@ 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 create Cash App session: ${error.message || response.statusText}`);
   }
-  const json = await response.json();
-  return json.data;
+  return response.json();
 }
-async function buildHypercoreTransaction(request, publishableKey) {
+async function getCashAppSessionStatus(externalId, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
   const response = await fetch(
-    `${API_BASE_URL}/v1/public/transactions/hypercore/build`,
+    `${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 build HyperCore transaction: ${error.message || response.statusText}`
+      `Failed to get Cash App session status: ${error.message || response.statusText}`
     );
   }
   return response.json();
 }
-async function getCashAppLimits(currency = "usd", 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/limits?currency=${encodeURIComponent(currency)}`,
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/default_token?${query.toString()}`,
     {
       method: "GET",
       headers: {
@@ -1026,71 +1113,315 @@ 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}`
-    );
+    throwStripeError("Failed to get Stripe default token", response, error);
   }
   return response.json();
 }
-async function createCashAppSession(request, publishableKey) {
+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}/v1/public/onramps/cashapp/sessions`,
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/customers/${encodeURIComponent(customerId)}`,
     {
-      method: "POST",
+      method: "GET",
       headers: {
         accept: "application/json",
         "x-publishable-key": pk,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
+        "x-stripe-oauth-token": oauthToken
+      }
     }
   );
   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}`
-    );
+    throwStripeError("Failed to get Stripe customer", response, error);
   }
   return response.json();
 }
-async function getCashAppSessionStatus(externalId, publishableKey) {
+async function stripeListWallets(customerId, oauthToken, publishableKey) {
   const pk = publishableKey || DEFAULT_PUBLISHABLE_KEY;
   validatePublishableKey(pk);
   const response = await fetch(
-    `${API_BASE_URL}/v1/public/onramps/cashapp/sessions/${encodeURIComponent(externalId)}/status`,
+    `${API_BASE_URL}${HEADLESS_STRIPE_BASE}/customers/${encodeURIComponent(customerId)}/wallet_addresses`,
     {
       method: "GET",
       headers: {
         accept: "application/json",
-        "x-publishable-key": pk
+        "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(
@@ -1099,6 +1430,133 @@ 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");
+}
+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) => {
@@ -1110,6 +1568,10 @@ var WithdrawEventType = /* @__PURE__ */ ((WithdrawEventType2) => {
   WithdrawEventType2["DIRECT_EXECUTION_SUCCEEDED"] = "direct_execution.succeeded";
   return WithdrawEventType2;
 })(WithdrawEventType || {});
+var CheckoutEventType = /* @__PURE__ */ ((CheckoutEventType2) => {
+  CheckoutEventType2["PAYMENT_INTENT_SUCCEEDED"] = "payment_intent.succeeded";
+  return CheckoutEventType2;
+})(CheckoutEventType || {});
 
 // src/hooks/use-user-ip.ts
 var import_react_query = require("@tanstack/react-query");
@@ -1245,11 +1707,13 @@ var i18n = en_default;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActionType,
+  CheckoutEventType,
   DepositEventType,
   ExecutionStatus,
   IneligibilityReason,
   IntegrationProvider,
   SOLANA_USDC_ADDRESS,
+  StripeApiResponseError,
   WithdrawEventType,
   authenticateIntegrationOAuth,
   buildHypercoreTransaction,
@@ -1257,19 +1721,25 @@ var i18n = en_default;
   checkHypercoreActivation,
   confirmIntegrationTransfer,
   createCashAppSession,
+  createCoinbaseApplePaySession,
   createDepositAddress,
   createExchangeSession,
   createIntegrationTransfer,
   createOnrampSession,
+  createOnrampVerificationSession,
+  exchangeOnrampVerificationToken,
   formatStablecoinAmount,
   generateKSUID,
   generatePrefixedKSUID,
   getAddressBalance,
   getAddressBalances,
   getApiBaseUrl,
+  getApplePayProviders,
+  getBankTransferProviders,
   getCashAppLimits,
   getCashAppSessionStatus,
   getChainName,
+  getCoinbaseLegalAgreements,
   getDefaultOnrampToken,
   getDepositAddress,
   getDepositQuote,
@@ -1285,6 +1755,7 @@ var i18n = en_default;
   getIpAddress,
   getOnrampQuotes,
   getOnrampSessionStartUrl,
+  getOnrampVerificationSession,
   getPreferredIconUrl,
   getProjectConfig,
   getSupportedDepositTokens,
@@ -1301,9 +1772,25 @@ var i18n = en_default;
   retrievePaymentIntent,
   revokeIntegrationToken,
   sendHypercoreTransaction,
+  sendOnrampVerificationOtp,
   sendSolanaTransaction,
   setApiConfig,
   startIntegrationOAuth,
+  stripeConfirmSession,
+  stripeCreateAuthIntent,
+  stripeCreateSession,
+  stripeExchangeTokens,
+  stripeGetConfig,
+  stripeGetCustomer,
+  stripeGetDefaultToken,
+  stripeGetQuotes,
+  stripeGetSession,
+  stripeGetTransactionLimits,
+  stripeListPaymentTokens,
+  stripeListWallets,
+  stripeRefreshQuote,
+  stripeRefreshToken,
   useUserIp,
+  verifyOnrampVerificationOtp,
   verifyRecipientAddress
 });