@rhinestone/deposit-modal 0.1.26 → 0.1.28

package/dist/{chunk-3FK5FAUL.mjs → chunk-RQSAANC3.mjs}

@@ -1,11 +1,9 @@
 import {
   CHAIN_BY_ID,
   NATIVE_TOKEN_ADDRESS,
-  SUPPORTED_CHAINS,
   getChainIcon,
   getChainName,
   getExplorerTxUrl,
-  getSupportedTokenSymbolsForChain,
   getTokenAddress,
   getTokenDecimalsByAddress,
   getTokenSymbol,
@@ -146,6 +144,71 @@ Modal.displayName = "Modal";
 function jsonReplacer(_key, value) {
   return typeof value === "bigint" ? value.toString() : value;
 }
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function toBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
+  if (typeof value === "string" && value.trim() !== "") return BigInt(value);
+  throw new Error("Invalid bigint value");
+}
+function normalizeSessionTypedData(raw) {
+  const data = structuredClone(raw);
+  const domain = asRecord(data.domain);
+  if (domain && domain.chainId !== void 0 && domain.chainId !== null) {
+    domain.chainId = toBigInt(domain.chainId);
+  }
+  const message = asRecord(data.message);
+  if (!message || !Array.isArray(message.sessionsAndChainIds)) {
+    return data;
+  }
+  for (const entry of message.sessionsAndChainIds) {
+    const chainSession = asRecord(entry);
+    if (!chainSession) continue;
+    if (chainSession.chainId !== void 0 && chainSession.chainId !== null) {
+      chainSession.chainId = toBigInt(chainSession.chainId);
+    }
+    const session = asRecord(chainSession.session);
+    if (!session) continue;
+    if (session.nonce !== void 0 && session.nonce !== null) {
+      session.nonce = toBigInt(session.nonce);
+    }
+    if (session.expires !== void 0 && session.expires !== null) {
+      session.expires = toBigInt(session.expires);
+    }
+  }
+  return data;
+}
+function normalizeSetupAccountResponse(raw) {
+  const data = raw;
+  return {
+    smartAccount: data.smartAccount,
+    isRegistered: data.isRegistered,
+    targetChain: data.targetChain,
+    targetToken: data.targetToken,
+    needsRegistration: data.needsRegistration,
+    accountParams: data.accountParams,
+    sessionDetailsUnsigned: data.sessionDetailsUnsigned ? {
+      hashesAndChainIds: data.sessionDetailsUnsigned.hashesAndChainIds.map(
+        (h) => ({
+          chainId: toBigInt(h.chainId),
+          sessionDigest: h.sessionDigest
+        })
+      ),
+      data: normalizeSessionTypedData(data.sessionDetailsUnsigned.data)
+    } : void 0
+  };
+}
+function buildSessionDetails(unsigned, signature) {
+  return {
+    hashesAndChainIds: unsigned.hashesAndChainIds.map((h) => ({
+      chainId: toBigInt(h.chainId),
+      sessionDigest: h.sessionDigest
+    })),
+    signature
+  };
+}
 function createDepositService(baseUrl) {
   const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
   function apiUrl(path) {
@@ -153,8 +216,8 @@ function createDepositService(baseUrl) {
     return `${normalizedBaseUrl}${normalizedPath}`;
   }
   return {
-    async prepareAccount(params) {
-      const response = await fetch(apiUrl("/prepare-account"), {
+    async setupAccount(params) {
+      const response = await fetch(apiUrl("/setup-account"), {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(params)
@@ -162,10 +225,10 @@ function createDepositService(baseUrl) {
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
         throw new Error(
-          error.error || `Prepare account failed: ${response.status}`
+          error.error || `Setup account failed: ${response.status}`
         );
       }
-      return response.json();
+      return normalizeSetupAccountResponse(await response.json());
     },
     async registerAccount(params) {
       const { eoaAddress, sessionOwner, ...account } = params;
@@ -189,17 +252,6 @@ function createDepositService(baseUrl) {
       }
       return response.json();
     },
-    async checkAccount(address) {
-      const response = await fetch(apiUrl(`/check/${address}`), {
-        method: "GET",
-        headers: { "Content-Type": "application/json" }
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({ error: "Unknown error" }));
-        throw new Error(error.error || `Check failed: ${response.status}`);
-      }
-      return response.json();
-    },
     async fetchPortfolio(address) {
       const response = await fetch(apiUrl(`/portfolio/${address}`), {
         method: "GET",
@@ -817,203 +869,6 @@ 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
-  };
-}
-function deserializeSessionData(raw) {
-  const data = structuredClone(raw);
-  const message = data.message;
-  if (!message?.sessionsAndChainIds) return data;
-  for (const entry of message.sessionsAndChainIds) {
-    const chainSession = entry;
-    chainSession.chainId = BigInt(chainSession.chainId);
-    const session = chainSession.session;
-    if (session) {
-      session.nonce = BigInt(session.nonce);
-      session.expires = BigInt(session.expires);
-    }
-  }
-  return data;
-}
-async function signSessionDetails(rhinestoneAccount, sessionDetailsUnsigned, signer) {
-  const data = deserializeSessionData(sessionDetailsUnsigned.data);
-  const hashesAndChainIds = sessionDetailsUnsigned.hashesAndChainIds.map(
-    (h) => ({
-      chainId: BigInt(h.chainId),
-      sessionDigest: h.sessionDigest
-    })
-  );
-  const sessionDetails = {
-    nonces: [],
-    hashesAndChainIds,
-    data
-  };
-  const signature = await signEnableSessionWithOwner(
-    rhinestoneAccount,
-    sessionDetails,
-    signer
-  );
-  return {
-    hashesAndChainIds,
-    signature
-  };
-}
-
 // src/core/session-owner.ts
 import { isAddress } from "viem";
 import {
@@ -1709,21 +1564,16 @@ export {
   Spinner,
   Button,
   ConnectStep,
-  createViewOnlyAccount,
-  createSmartAccount,
-  getAccountAddress,
-  getAccountInitData,
-  getSessionDetails,
-  signSessionDetails,
+  buildSessionDetails,
+  createDepositService,
+  getAssetId,
+  portfolioToAssets,
+  isNativeAsset,
   loadSessionOwnerFromStorage,
   saveSessionOwnerToStorage,
   createSessionOwnerKey,
   accountFromPrivateKey,
   PoweredBy,
-  createDepositService,
-  getAssetId,
-  portfolioToAssets,
-  isNativeAsset,
   currencyFormatter,
   tokenFormatter,
   formatUserError,