@0xkey-io/react-wallet-kit 0.1.1 → 0.3.0

package/dist/providers/client/Provider.js

@@ -35,6 +35,7 @@ var OTP = require('../../components/auth/OTP.js');
 var RemoveEmail = require('../../components/user/RemoveEmail.js');
 var RemovePhoneNumber = require('../../components/user/RemovePhoneNumber.js');
 var Verify = require('../../components/verify/Verify.js');
+var VerifyEnclave = require('../../components/verify/VerifyEnclave.js');
 var OnRamp = require('../../components/onramp/OnRamp.js');
 var Svg = require('../../components/design/Svg.js');
 var SendTransaction = require('../../components/send-transaction/SendTransaction.js');
@@ -1765,6 +1766,14 @@ const ClientProvider = ({
     if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withZeroXKeyErrorHandling(() => client.fetchBootProofForAppProof(params), () => logout(), callbacks, "Failed to fetch or create delegated access user");
   }, [client, callbacks, logout]);
+  const fetchLatestBootProof = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.fetchLatestBootProof(params), () => logout(), callbacks, "Failed to get the latest boot proof");
+  }, [client, callbacks, logout]);
+  const verifyLatestBootProof = react.useCallback(async params => {
+    if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    return utils.withZeroXKeyErrorHandling(() => client.verifyLatestBootProof(params), () => logout(), callbacks, "Failed to verify the latest boot proof");
+  }, [client, callbacks, logout]);
   const verifyAppProofs = react.useCallback(async params => {
     if (!client) throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
     return utils.withZeroXKeyErrorHandling(() => client.verifyAppProofs(params), () => logout(), callbacks, "Failed to verify app proofs");
@@ -3516,48 +3525,39 @@ const ClientProvider = ({
       urlForSignature,
       countryCode,
       onrampProvider = "FIAT_ON_RAMP_PROVIDER_MOONPAY",
-      sandboxMode = true,
       successPageDuration = 2000,
-      openInNewTab = false
+      openInNewTab = false,
+      openMode,
+      polling,
+      onStatusChange
     } = params;
+    if (params.sandboxMode === undefined) {
+      throw new core.OnRampError(core.OnRampErrorCode.SANDBOX_MODE_REQUIRED, "sandboxMode must be explicitly set for on-ramp flows.");
+    }
+    // Fail fast (before opening any modal/window) when the provider has no
+    // supported runtime, so callers get a typed error instead of a popup.
+    core.assertOnRampProviderSupported(onrampProvider);
+    if (!client?.httpClient) {
+      throw new sdkTypes.ZeroXKeyError("Client is not initialized.", sdkTypes.ZeroXKeyErrorCodes.CLIENT_NOT_INITIALIZED);
+    }
     const s = await getSession();
     const organizationId = params?.organizationId || s?.organizationId;
     if (!organizationId) {
       throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
     }
-    let cryptoCurrencyCode;
-    let network;
-    switch (true) {
-      case walletAccount.addressFormat === "ADDRESS_FORMAT_ETHEREUM":
-        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.ETHEREUM;
-        network = sdkTypes.FiatOnRampBlockchainNetwork.ETHEREUM;
-        break;
-      case walletAccount.addressFormat?.includes("ADDRESS_FORMAT_BITCOIN"):
-        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.BITCOIN;
-        network = sdkTypes.FiatOnRampBlockchainNetwork.BITCOIN;
-        break;
-      case walletAccount.addressFormat === "ADDRESS_FORMAT_SOLANA":
-        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.SOLANA;
-        network = sdkTypes.FiatOnRampBlockchainNetwork.SOLANA;
-        break;
-      default:
-        cryptoCurrencyCode = sdkTypes.FiatOnRampCryptoCurrency.ETHEREUM;
-        network = sdkTypes.FiatOnRampBlockchainNetwork.ETHEREUM;
-        break;
-    }
-    const openNewTab = openInNewTab || isMobile;
-    cryptoCurrencyCode = params.cryptoCurrencyCode || cryptoCurrencyCode;
-    network = params.network || network;
+    const inferredAsset = params.network && params.cryptoCurrencyCode ? undefined : core.inferOnRampAssetFromWalletAccount(walletAccount);
+    const cryptoCurrencyCode = params.cryptoCurrencyCode ?? inferredAsset?.cryptoCurrencyCode;
+    const network = params.network ?? inferredAsset?.network;
+    if (!cryptoCurrencyCode || !network) {
+      throw new core.OnRampError(core.OnRampErrorCode.ASSET_REQUIRED, "network and cryptoCurrencyCode are required for on-ramp flows.");
+    }
+    const resolvedOpenMode = openMode ?? (openInNewTab || isMobile ? "newTab" : "popup");
     return new Promise((resolve, reject) => {
       const OnRampContainer = () => {
         const [completed, setCompleted] = react.useState(false);
-        const pollingRef = react.useRef(null);
-        const cleanup = () => {
-          if (pollingRef.current) {
-            clearInterval(pollingRef.current);
-            pollingRef.current = null;
-          }
-        };
+        const [result, setResult] = react.useState();
+        const abortRef = react.useRef(null);
+        const cleanup = () => abortRef.current?.abort();
         react.useEffect(() => {
           return () => {
             cleanup();
@@ -3566,17 +3566,21 @@ const ClientProvider = ({
         const action = async () => {
           try {
             let onRampWindow = null;
-            if (openNewTab) {
+            if (resolvedOpenMode === "newTab") {
               onRampWindow = window.open("", "_blank");
-              if (!onRampWindow) throw new Error("Failed to open On Ramp tab.");
+              if (!onRampWindow) throw new core.OnRampError(core.OnRampErrorCode.POPUP_BLOCKED, "Failed to open On Ramp tab.");
             }
-            const result = await client?.httpClient?.initFiatOnRamp({
+            const initResult = await core.initOnRampFlow({
+              runtimeClient: client.httpClient,
               onrampProvider,
               walletAddress: walletAccount.address,
               network,
               cryptoCurrencyCode,
-              sandboxMode,
               organizationId,
+              sandboxMode: params.sandboxMode,
+              ...(params.stampWith ? {
+                stampWith: params.stampWith
+              } : {}),
               ...(fiatCurrencyCode ? {
                 fiatCurrencyCode
               } : {}),
@@ -3592,63 +3596,63 @@ const ClientProvider = ({
               ...(countrySubdivisionCode ? {
                 countrySubdivisionCode
               } : {}),
-              ...(sandboxMode !== undefined ? {
-                sandboxMode
-              } : {}),
               ...(urlForSignature ? {
                 urlForSignature
               } : {})
             });
-            if (!result?.onRampUrl) throw new Error("Missing onRampUrl");
-            if (openNewTab && onRampWindow) {
-              onRampWindow.location.href = result.onRampUrl.toString();
+            onStatusChange?.(initResult);
+            if (resolvedOpenMode === "returnUrl") {
+              setResult(initResult);
+              setCompleted(true);
+              return;
+            }
+            const providerUrl = initResult.signedUrl ?? initResult.onRampUrl;
+            if (resolvedOpenMode === "newTab" && onRampWindow) {
+              onRampWindow.location.href = providerUrl;
             } else {
               const popupWidth = 500;
               const popupHeight = 600;
               const left = window.screenX + (window.innerWidth - popupWidth) / 2;
               const top = window.screenY + (window.innerHeight - popupHeight) / 2;
-              onRampWindow = window.open(result.onRampUrl.toString(), "_blank", `width=${popupWidth},height=${popupHeight},top=${top},left=${left},scrollbars=yes,resizable=yes`);
-              if (!onRampWindow) throw new Error("Failed to open On Ramp window.");
+              onRampWindow = window.open(providerUrl, "_blank", `width=${popupWidth},height=${popupHeight},top=${top},left=${left},scrollbars=yes,resizable=yes`);
+              if (!onRampWindow) throw new core.OnRampError(core.OnRampErrorCode.POPUP_BLOCKED, "Failed to open On Ramp window.");
             }
-            const onRampTransactionId = result.onRampTransactionId;
-            if (!onRampTransactionId) throw new Error("No onRampTransactionId returned");
-            return new Promise((resolveAction, rejectAction) => {
-              pollingRef.current = setInterval(async () => {
-                try {
-                  if (onrampProvider === "FIAT_ON_RAMP_PROVIDER_COINBASE" && onRampWindow?.closed) {
-                    cleanup();
-                    rejectAction(new Error("On-ramp popup closed by user"));
-                    return;
-                  }
-                  let currentUrl = "";
-                  try {
-                    currentUrl = onRampWindow?.location.href || "";
-                  } catch {}
-                  if (currentUrl && currentUrl.startsWith(window.location.origin)) {
-                    cleanup();
-                    onRampWindow?.close();
-                    setCompleted(true);
-                    resolveAction();
-                    return;
-                  }
-                  const resp = await client?.httpClient?.getOnRampTransactionStatus({
-                    transactionId: onRampTransactionId,
-                    refresh: true
-                  });
-                  const status = resp?.transactionStatus;
-                  if (["COMPLETED", "FAILED", "CANCELLED"].includes(status ?? "")) {
-                    cleanup();
-                    try {
-                      onRampWindow?.close();
-                    } catch {}
-                    setCompleted(true);
-                    resolveAction();
-                  }
-                } catch (error) {
-                  console.warn("Polling error (ignored):", error);
-                }
-              }, 3000);
+            abortRef.current = new AbortController();
+            const status = await core.pollOnRampTransactionStatus({
+              runtimeClient: client.httpClient,
+              organizationId,
+              transactionId: initResult.onRampTransactionId,
+              refresh: polling?.refresh ?? true,
+              signal: abortRef.current.signal,
+              onStatusUpdate: polledStatus => {
+                onStatusChange?.({
+                  ...initResult,
+                  status: polledStatus
+                });
+              },
+              ...(params.stampWith ? {
+                stampWith: params.stampWith
+              } : {}),
+              ...(polling?.intervalMs ? {
+                intervalMs: polling.intervalMs
+              } : {}),
+              ...(polling?.timeoutMs ? {
+                timeoutMs: polling.timeoutMs
+              } : {}),
+              ...(polling?.maxConsecutiveErrors ? {
+                maxConsecutiveErrors: polling.maxConsecutiveErrors
+              } : {})
+            });
+            try {
+              onRampWindow?.close();
+            } catch {}
+            // The terminal status was already emitted via onStatusUpdate
+            // inside pollOnRampTransactionStatus; avoid a duplicate callback.
+            setResult({
+              ...initResult,
+              status
             });
+            setCompleted(true);
           } catch (err) {
             cleanup();
             throw err;
@@ -3662,10 +3666,11 @@ const ClientProvider = ({
           }),
           onrampProvider: onrampProvider,
           action: action,
-          sandboxMode: sandboxMode,
+          sandboxMode: params.sandboxMode,
           completed: completed,
+          result: result,
           successPageDuration: successPageDuration,
-          onSuccess: () => resolve(),
+          onSuccess: resolvedResult => resolve(resolvedResult),
           onError: err => reject(err)
         });
       };
@@ -3674,7 +3679,9 @@ const ClientProvider = ({
         content: jsxRuntime.jsx(OnRampContainer, {}),
         showTitle: false,
         preventBack: true,
-        onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the onramp process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+        onClose: () => {
+          reject(new core.OnRampError(core.OnRampErrorCode.USER_ABORTED, "User canceled the onramp process."));
+        }
       });
     });
   }, [getSession, client, pushPage]);
@@ -3721,6 +3728,53 @@ const ClientProvider = ({
       throw new sdkTypes.ZeroXKeyError("Failed to verify app proofs.", sdkTypes.ZeroXKeyErrorCodes.VERIFY_APP_PROOFS_ERROR, error);
     }
   }, [getSession, pushPage]);
+  const handleVerifyEnclave = react.useCallback(async params => {
+    const {
+      appName,
+      successPageDuration = 3000,
+      stampWith,
+      anchor
+    } = params || {};
+    const s = await getSession();
+    const organizationId = params?.organizationId || s?.organizationId;
+    if (!organizationId) {
+      throw new sdkTypes.ZeroXKeyError("A session or passed in organization ID is required.", sdkTypes.ZeroXKeyErrorCodes.INVALID_REQUEST);
+    }
+    try {
+      return await new Promise((resolve, reject) => {
+        pushPage({
+          key: "Verify enclave",
+          content: jsxRuntime.jsx(VerifyEnclave.VerifyEnclavePage, {
+            appName: appName,
+            onSuccess: pivotHashHex => {
+              resolve(pivotHashHex);
+            },
+            onError: error => {
+              reject(error);
+            },
+            successPageDuration: successPageDuration,
+            ...(stampWith && {
+              stampWith
+            }),
+            ...(anchor && {
+              anchor
+            }),
+            ...(organizationId !== undefined && {
+              organizationId
+            })
+          }),
+          showTitle: false,
+          preventBack: true,
+          onClose: () => reject(new sdkTypes.ZeroXKeyError("User canceled the verify enclave process.", sdkTypes.ZeroXKeyErrorCodes.USER_CANCELED))
+        });
+      });
+    } catch (error) {
+      if (error instanceof sdkTypes.ZeroXKeyError) {
+        throw error;
+      }
+      throw new sdkTypes.ZeroXKeyError("Failed to verify enclave.", sdkTypes.ZeroXKeyErrorCodes.VERIFY_LATEST_BOOT_PROOF_ERROR, error);
+    }
+  }, [getSession, pushPage]);
   react.useEffect(() => {
     if (proxyAuthConfigRef.current) return;
     // Only fetch the proxy auth config once. Use that to build the master config.
@@ -3896,6 +3950,8 @@ const ClientProvider = ({
       createApiKeyPair,
       getProxyAuthConfig,
       fetchBootProofForAppProof,
+      fetchLatestBootProof,
+      verifyLatestBootProof,
       verifyAppProofs,
       handleLogin,
       handleGoogleOauth,
@@ -3922,6 +3978,7 @@ const ClientProvider = ({
       handleRemoveUserEmail,
       handleRemoveUserPhoneNumber,
       handleVerifyAppProofs,
+      handleVerifyEnclave,
       handleOnRamp,
       handleSendTransaction,
       handleSendErc20Transfer