@rhinestone/deposit-modal 0.1.24 → 0.1.25

package/dist/{chunk-P7SQQAAF.mjs → chunk-GAFLOODV.mjs}

@@ -1,9 +1,11 @@
 import {
   CHAIN_BY_ID,
   NATIVE_TOKEN_ADDRESS,
+  SUPPORTED_CHAINS,
   getChainIcon,
   getChainName,
   getExplorerTxUrl,
+  getSupportedTokenSymbolsForChain,
   getTokenAddress,
   getTokenDecimalsByAddress,
   getTokenSymbol,
@@ -151,21 +153,6 @@ function createDepositService(baseUrl) {
     return `${normalizedBaseUrl}${normalizedPath}`;
   }
   return {
-    async prepareAccount(params) {
-      const response = await fetch(apiUrl("/prepare-account"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(params, jsonReplacer)
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({ error: "Unknown error" }));
-        throw new Error(
-          error.error || `Prepare account failed: ${response.status}`
-        );
-      }
-      const payload = await response.json();
-      return normalizePrepareAccountResponse(payload);
-    },
     async registerAccount(params) {
       const { eoaAddress, sessionOwner, ...account } = params;
       const response = await fetch(apiUrl("/register"), {
@@ -246,58 +233,40 @@ function createDepositService(baseUrl) {
         return { lastEvent: void 0 };
       }
       return response.json();
-    }
-  };
-}
-function buildSessionDetails(sessionDetailsUnsigned, signature) {
-  return {
-    hashesAndChainIds: sessionDetailsUnsigned.hashesAndChainIds,
-    signature
-  };
-}
-function normalizePrepareAccountResponse(payload) {
-  if (!isRecord(payload)) {
-    throw new Error("Invalid prepare-account response");
-  }
-  const smartAccount = extractString(payload, "smartAccount");
-  const accountParams = isRecord(payload.accountParams) ? payload.accountParams : null;
-  const sessionDetailsUnsigned = isRecord(payload.sessionDetailsUnsigned) ? payload.sessionDetailsUnsigned : null;
-  if (!smartAccount || !accountParams || !sessionDetailsUnsigned) {
-    throw new Error("Missing prepare-account fields");
-  }
-  const factory = extractString(accountParams, "factory");
-  const factoryData = extractString(accountParams, "factoryData");
-  if (!factory || !factoryData) {
-    throw new Error("Invalid account params from prepare-account");
-  }
-  const rawHashes = Array.isArray(sessionDetailsUnsigned.hashesAndChainIds) ? sessionDetailsUnsigned.hashesAndChainIds : null;
-  if (!rawHashes) {
-    throw new Error("Missing session hashes from prepare-account");
-  }
-  const hashesAndChainIds = rawHashes.map((value) => {
-    if (!isRecord(value)) return null;
-    const sessionDigest = extractString(value, "sessionDigest");
-    const chainId = toBigInt(value.chainId);
-    if (!sessionDigest || chainId === null) return null;
-    return {
-      chainId,
-      sessionDigest
-    };
-  }).filter(
-    (item) => item !== null
-  );
-  if (hashesAndChainIds.length === 0) {
-    throw new Error("Session hashes are empty");
-  }
-  return {
-    smartAccount,
-    accountParams: {
-      factory,
-      factoryData
     },
-    sessionDetailsUnsigned: {
-      hashesAndChainIds,
-      data: sessionDetailsUnsigned.data
+    async relayWithdraw(params) {
+      const { smartAccount, chainId, safeAddress, safeTransaction, signature } = params;
+      const response = await fetch(apiUrl(`/relay-withdraw`), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(
+          {
+            chainId,
+            safeAddress,
+            safeTransaction: {
+              to: safeTransaction.to,
+              value: safeTransaction.value.toString(),
+              data: safeTransaction.data,
+              operation: safeTransaction.operation,
+              safeTxGas: safeTransaction.safeTxGas.toString(),
+              baseGas: safeTransaction.baseGas.toString(),
+              gasPrice: safeTransaction.gasPrice.toString(),
+              gasToken: safeTransaction.gasToken,
+              refundReceiver: safeTransaction.refundReceiver,
+              nonce: safeTransaction.nonce.toString()
+            },
+            signature
+          },
+          jsonReplacer
+        )
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        throw new Error(
+          error.error || `Relay withdraw failed: ${response.status}`
+        );
+      }
+      return response.json();
     }
   };
 }
@@ -386,23 +355,6 @@ function extractTokenAddress(tokenData, chainId) {
   const token = tokenData;
   return token.tokenAddress ?? token.address ?? token.addresses?.[chainId] ?? token.token?.address ?? token.token?.addresses?.[chainId];
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function toBigInt(value) {
-  if (typeof value === "bigint") return value;
-  if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
-    return BigInt(value);
-  }
-  if (typeof value === "string" && /^\d+$/.test(value)) {
-    try {
-      return BigInt(value);
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
 function extractArray(data, key) {
   if (!data || typeof data !== "object") return null;
   const record = data;
@@ -851,6 +803,165 @@ function ConnectStep({
 }
 ConnectStep.displayName = "ConnectStep";
 
+// src/core/account.ts
+import {
+  RhinestoneSDK
+} from "@rhinestone/sdk";
+import { zeroAddress } from "viem";
+import { toAccount } from "viem/accounts";
+function createViewOnlyAccount(address) {
+  if (!address || address === zeroAddress) {
+    throw new Error("Address is required");
+  }
+  return toAccount({
+    address,
+    signMessage: async () => {
+      throw new Error("Account is view-only");
+    },
+    signTransaction: async () => {
+      throw new Error("Account is view-only");
+    },
+    signTypedData: async () => {
+      throw new Error("Account is view-only");
+    }
+  });
+}
+function getSessionSignerAccount(signerAddress) {
+  if (!signerAddress || signerAddress === zeroAddress) {
+    throw new Error("Signer address is required");
+  }
+  return toAccount({
+    address: signerAddress,
+    signMessage: async () => {
+      throw new Error("Session signer is view-only");
+    },
+    signTransaction: async () => {
+      throw new Error("Session signer is view-only");
+    },
+    signTypedData: async () => {
+      throw new Error("Session signer is view-only");
+    }
+  });
+}
+function buildSession(chain, signerAddress) {
+  const sessionSignerAccount = getSessionSignerAccount(signerAddress);
+  return {
+    owners: {
+      type: "ecdsa",
+      accounts: [sessionSignerAccount]
+    },
+    chain
+  };
+}
+async function createSmartAccount(userSigner, sessionSigner, sdkApiKey) {
+  const rhinestone = new RhinestoneSDK({
+    apiKey: sdkApiKey ?? ""
+  });
+  const ownerAccounts = sessionSigner ? [userSigner, sessionSigner] : [userSigner];
+  const config = {
+    account: {
+      type: "nexus"
+    },
+    owners: {
+      type: "ecdsa",
+      accounts: ownerAccounts,
+      ...sessionSigner ? { threshold: 1 } : {}
+    },
+    experimental_sessions: {
+      enabled: true
+    }
+  };
+  const account = await rhinestone.createAccount(config);
+  return account;
+}
+function getAccountAddress(account) {
+  return account.getAddress();
+}
+function getAccountInitData(account) {
+  const { factory, factoryData } = account.getInitData();
+  if (!factory) {
+    throw new Error("Account init data is not available");
+  }
+  return {
+    factory,
+    factoryData
+  };
+}
+async function signEnableSessionWithOwner(rhinestoneAccount, sessionDetails, signer) {
+  const originalOwners = rhinestoneAccount.config.owners;
+  rhinestoneAccount.config.owners = {
+    type: "ecdsa",
+    accounts: [signer],
+    threshold: 1,
+    ...originalOwners?.type === "ecdsa" && originalOwners.module ? { module: originalOwners.module } : {}
+  };
+  try {
+    return await rhinestoneAccount.experimental_signEnableSession(
+      sessionDetails
+    );
+  } finally {
+    rhinestoneAccount.config.owners = originalOwners;
+  }
+}
+async function getSessionDetails(rhinestoneAccount, targetChain, signerAddress, sessionSigner, targetToken, sessionChainIds) {
+  const isTargetTestnet = Boolean(targetChain.testnet);
+  const chainsByNetworkType = SUPPORTED_CHAINS.filter(
+    (chain) => Boolean(chain.testnet) === isTargetTestnet
+  );
+  const chainsById = new Map(
+    chainsByNetworkType.map((chain) => [chain.id, chain])
+  );
+  let selectedChains = [...chainsByNetworkType];
+  if (sessionChainIds && sessionChainIds.length > 0) {
+    const selectedByCaller = [];
+    for (const chainId of sessionChainIds) {
+      const chain = chainsById.get(chainId);
+      if (chain) {
+        selectedByCaller.push(chain);
+      }
+    }
+    if (selectedByCaller.length > 0) {
+      selectedChains = selectedByCaller;
+    }
+  }
+  if (targetToken) {
+    const targetSymbol = getTokenSymbol(
+      targetToken,
+      targetChain.id
+    ).toUpperCase();
+    if (targetSymbol && targetSymbol !== "TOKEN") {
+      const chainsForToken = selectedChains.filter(
+        (chain) => getSupportedTokenSymbolsForChain(chain.id).includes(targetSymbol)
+      );
+      if (chainsForToken.length > 0) {
+        selectedChains = chainsForToken;
+      }
+    }
+  }
+  if (!selectedChains.some((c) => c.id === targetChain.id)) {
+    selectedChains.push(targetChain);
+  }
+  const uniqueChains = Array.from(
+    new Map(selectedChains.map((chain) => [chain.id, chain])).values()
+  );
+  const sessions = uniqueChains.map(
+    (chain) => buildSession(chain, signerAddress)
+  );
+  const sessionDetails = await rhinestoneAccount.experimental_getSessionDetails(sessions);
+  const enableSignature = sessionSigner ? await signEnableSessionWithOwner(
+    rhinestoneAccount,
+    sessionDetails,
+    sessionSigner
+  ) : await rhinestoneAccount.experimental_signEnableSession(sessionDetails);
+  if (!sessionDetails.hashesAndChainIds?.length) {
+    throw new Error("Session details missing chain digests");
+  }
+  return {
+    hashesAndChainIds: sessionDetails.hashesAndChainIds,
+    signature: enableSignature
+  };
+}
+
 // src/core/session-owner.ts
 import { isAddress } from "viem";
 import {
@@ -942,7 +1053,7 @@ function PoweredBy() {
 }
 
 // src/core/webhook.ts
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function asString(value) {
@@ -954,11 +1065,11 @@ function getEventTxHash(event) {
     return asString(event.data?.transactionHash);
   }
   if (event.type === "bridge-started" || event.type === "bridge-complete") {
-    const deposit = isRecord2(event.data?.deposit) ? event.data.deposit : void 0;
+    const deposit = isRecord(event.data?.deposit) ? event.data.deposit : void 0;
     return asString(deposit?.transactionHash);
   }
   if (event.type === "bridge-failed" || event.type === "error") {
-    const deposit = isRecord2(event.data?.deposit) ? event.data.deposit : void 0;
+    const deposit = isRecord(event.data?.deposit) ? event.data.deposit : void 0;
     return asString(deposit?.transactionHash);
   }
   return void 0;
@@ -1546,16 +1657,20 @@ export {
   Spinner,
   Button,
   ConnectStep,
+  createViewOnlyAccount,
+  createSmartAccount,
+  getAccountAddress,
+  getAccountInitData,
+  getSessionDetails,
   loadSessionOwnerFromStorage,
   saveSessionOwnerToStorage,
   createSessionOwnerKey,
   accountFromPrivateKey,
+  PoweredBy,
   createDepositService,
-  buildSessionDetails,
   getAssetId,
   portfolioToAssets,
   isNativeAsset,
-  PoweredBy,
   currencyFormatter,
   tokenFormatter,
   formatUserError,

package/dist/{chunk-ZMVCDFXM.mjs → chunk-JAR372KJ.mjs}

@@ -7,21 +7,25 @@ import {
   Spinner,
   accountFromPrivateKey,
   applyTheme,
-  buildSessionDetails,
   createDepositService,
   createSessionOwnerKey,
+  createSmartAccount,
+  createViewOnlyAccount,
   currencyFormatter,
   formatUserError,
+  getAccountAddress,
+  getAccountInitData,
   getAssetId,
   getEventTxHash,
   getPublicClient,
+  getSessionDetails,
   isDepositEvent,
   isNativeAsset,
   loadSessionOwnerFromStorage,
   portfolioToAssets,
   saveSessionOwnerToStorage,
   tokenFormatter
-} from "./chunk-P7SQQAAF.mjs";
+} from "./chunk-GAFLOODV.mjs";
 import {
   CHAIN_BY_ID,
   DEFAULT_BACKEND_URL,
@@ -45,7 +49,9 @@ import {
   useEffect as useEffect7,
   useRef as useRef5,
   useState as useState8,
-  useCallback as useCallback4
+  useCallback as useCallback4,
+  lazy,
+  Suspense
 } from "react";
 
 // src/DepositFlow.tsx
@@ -53,6 +59,7 @@ import { useState as useState7, useCallback as useCallback3, useMemo as useMemo6
 
 // src/components/steps/SetupStep.tsx
 import { useState, useEffect, useRef, useCallback } from "react";
+import { walletClientToAccount } from "@rhinestone/sdk";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 async function resolveSessionOwner(eoaAddress) {
   const localOwner = loadSessionOwnerFromStorage(eoaAddress);
@@ -73,7 +80,9 @@ function SetupStep({
   walletClient,
   address,
   targetChain,
+  targetChainObj,
   targetToken,
+  rhinestoneApiKey,
   signerAddress,
   sessionChainIds,
   recipient,
@@ -85,18 +94,8 @@ function SetupStep({
 }) {
   const [state, setState] = useState({ type: "idle" });
   const setupInitiatedRef = useRef(false);
-  const signSessionDetails = useCallback(
-    async (sessionOwner, typedData) => {
-      const signer = sessionOwner.account;
-      if (!signer.signTypedData) {
-        throw new Error("Session owner cannot sign typed data");
-      }
-      return await signer.signTypedData(typedData);
-    },
-    []
-  );
   const runSetup = useCallback(async () => {
-    if (!address) {
+    if (!address || !targetChainObj) {
       return;
     }
     if (walletClient && !walletClient.account) {
@@ -104,16 +103,14 @@ function SetupStep({
     }
     try {
       setState({ type: "creating-account" });
+      const signerAccount = walletClient ? walletClientToAccount(walletClient) : createViewOnlyAccount(address);
       const sessionOwner = await resolveSessionOwner(address);
-      const prepared = await service.prepareAccount({
-        ownerAddress: address,
-        sessionOwnerAddress: sessionOwner.address,
-        targetChain,
-        targetToken,
-        signerAddress,
-        sessionChainIds
-      });
-      const smartAccount = prepared.smartAccount;
+      const account = await createSmartAccount(
+        signerAccount,
+        sessionOwner.account,
+        rhinestoneApiKey
+      );
+      const smartAccount = getAccountAddress(account);
       setState({ type: "checking" });
       const checkResult = await service.checkAccount(smartAccount);
       if (checkResult.isRegistered && !forceRegister) {
@@ -126,20 +123,21 @@ function SetupStep({
         }
       }
       setState({ type: "signing-session" });
-      const signature = await signSessionDetails(
-        sessionOwner,
-        prepared.sessionDetailsUnsigned.data
-      );
-      const sessionDetails = buildSessionDetails(
-        prepared.sessionDetailsUnsigned,
-        signature
+      const initData = getAccountInitData(account);
+      const sessionDetails = await getSessionDetails(
+        account,
+        targetChainObj,
+        signerAddress,
+        sessionOwner.account,
+        targetToken,
+        sessionChainIds
       );
       setState({ type: "registering" });
       await service.registerAccount({
         address: smartAccount,
         accountParams: {
-          factory: prepared.accountParams.factory,
-          factoryData: prepared.accountParams.factoryData,
+          factory: initData.factory,
+          factoryData: initData.factoryData,
           sessionDetails
         },
         eoaAddress: address,
@@ -161,8 +159,10 @@ function SetupStep({
   }, [
     address,
     walletClient,
+    targetChainObj,
     targetChain,
     targetToken,
+    rhinestoneApiKey,
     signerAddress,
     sessionChainIds,
     recipient,
@@ -170,16 +170,15 @@ function SetupStep({
     service,
     onSetupComplete,
     onError,
-    onConnected,
-    signSessionDetails
+    onConnected
   ]);
   useEffect(() => {
     const hasWallet = walletClient ? Boolean(walletClient.account) : true;
-    if (address && hasWallet && !setupInitiatedRef.current && state.type === "idle") {
+    if (address && hasWallet && targetChainObj && !setupInitiatedRef.current && state.type === "idle") {
       setupInitiatedRef.current = true;
       runSetup();
     }
-  }, [address, walletClient, state.type, runSetup]);
+  }, [address, walletClient, targetChainObj, state.type, runSetup]);
   const handleRetry = () => {
     setupInitiatedRef.current = false;
     setState({ type: "idle" });
@@ -1651,6 +1650,7 @@ function DepositFlow({
   sourceToken: defaultSourceToken,
   amount: defaultAmount,
   recipient,
+  rhinestoneApiKey,
   signerAddress = DEFAULT_SIGNER_ADDRESS,
   sessionChainIds,
   forceRegister = false,
@@ -1973,7 +1973,9 @@ function DepositFlow({
         {
           address: sessionKeyAddress,
           targetChain,
+          targetChainObj,
           targetToken,
+          rhinestoneApiKey,
           signerAddress,
           sessionChainIds,
           recipient,
@@ -2034,7 +2036,9 @@ function DepositFlow({
         walletClient: signerContext.walletClient,
         address: ownerAddress,
         targetChain,
+        targetChainObj,
         targetToken,
+        rhinestoneApiKey,
         signerAddress,
         sessionChainIds,
         recipient,
@@ -2115,11 +2119,13 @@ function DepositFlow({
 
 // src/DepositModal.tsx
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var ReownDepositInner = lazy(
+  () => import("./DepositModalReown-4A5HJK74.mjs").then((m) => ({ default: m.DepositModalReown }))
+);
 function DepositModal(props) {
-  if (props.reownAppId) {
-    throw new Error(
-      'Reown support moved to "@rhinestone/deposit-modal/reown". Use that entrypoint when passing reownAppId.'
-    );
+  const needsReown = !!props.reownAppId;
+  if (needsReown) {
+    return /* @__PURE__ */ jsx8(Suspense, { fallback: null, children: /* @__PURE__ */ jsx8(ReownDepositInner, { ...props }) });
   }
   return /* @__PURE__ */ jsx8(DepositModalInner, { ...props });
 }
@@ -2138,6 +2144,7 @@ function DepositModalInner({
   defaultAmount,
   recipient,
   backendUrl = DEFAULT_BACKEND_URL,
+  rhinestoneApiKey,
   signerAddress = DEFAULT_SIGNER_ADDRESS,
   sessionChainIds,
   forceRegister = false,
@@ -2307,6 +2314,7 @@ function DepositModalInner({
             sourceToken,
             amount: defaultAmount,
             recipient,
+            rhinestoneApiKey,
             signerAddress,
             sessionChainIds,
             forceRegister,

package/dist/chunk-LBEP3A2Z.mjs

@@ -0,0 +1,90 @@
+// src/core/reown.tsx
+import { useState } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { WagmiAdapter } from "@reown/appkit-adapter-wagmi";
+import { WagmiProvider } from "wagmi";
+import { createAppKit, useAppKit, useAppKitAccount } from "@reown/appkit/react";
+import {
+  mainnet,
+  base,
+  arbitrum,
+  optimism,
+  polygon,
+  bsc
+} from "@reown/appkit/networks";
+import { useWalletClient, usePublicClient, useSwitchChain } from "wagmi";
+import { jsx } from "react/jsx-runtime";
+var NETWORKS = [
+  mainnet,
+  base,
+  arbitrum,
+  optimism,
+  polygon,
+  bsc
+];
+var cachedAdapter = null;
+var cachedProjectId = null;
+function mapTheme(theme) {
+  const themeMode = theme?.mode === "light" ? "light" : "dark";
+  const themeVariables = {};
+  if (theme?.ctaColor) {
+    themeVariables["--apkt-accent"] = theme.ctaColor;
+  }
+  return { themeMode, themeVariables };
+}
+function getOrCreateAdapter(projectId, theme) {
+  if (cachedAdapter && cachedProjectId === projectId) return cachedAdapter;
+  cachedAdapter = new WagmiAdapter({
+    networks: NETWORKS,
+    projectId
+  });
+  cachedProjectId = projectId;
+  const { themeMode, themeVariables } = mapTheme(theme);
+  createAppKit({
+    adapters: [cachedAdapter],
+    networks: NETWORKS,
+    projectId,
+    themeMode,
+    themeVariables,
+    features: {
+      connectMethodsOrder: ["wallet"],
+      email: false,
+      socials: false
+    }
+  });
+  return cachedAdapter;
+}
+function ReownWalletProvider({
+  projectId,
+  theme,
+  children
+}) {
+  const [queryClient] = useState(() => new QueryClient());
+  const adapter = getOrCreateAdapter(projectId, theme);
+  const config = adapter.wagmiConfig;
+  return /* @__PURE__ */ jsx(WagmiProvider, { config, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children }) });
+}
+function useReownWallet() {
+  const { open } = useAppKit();
+  const { address, isConnected } = useAppKitAccount();
+  const { data: walletClient } = useWalletClient();
+  const publicClient = usePublicClient();
+  const { switchChainAsync } = useSwitchChain();
+  return {
+    walletClient: walletClient ?? void 0,
+    publicClient: publicClient ?? void 0,
+    address,
+    isConnected,
+    openConnect: () => {
+      void open({ view: isConnected ? "Account" : "Connect" });
+    },
+    switchChain: async (chainId) => {
+      await switchChainAsync({ chainId });
+    }
+  };
+}
+
+export {
+  ReownWalletProvider,
+  useReownWallet
+};