@swype-org/react-sdk 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -527,160 +527,10 @@ async function getWalletClient(config, parameters = {}) {
   const client = await getConnectorClient(config, parameters);
   return client.extend(viem.walletActions);
 }
-
-// src/authorization/upgrade.ts
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function isValidChainId(value) {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function isRpcClient(value) {
-  return typeof value === "object" && value !== null && "request" in value && typeof value.request === "function";
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function pollCallsStatus(client, bundleId, label, timeoutMs = 12e4, intervalMs = 3e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const raw = await client.request({
-      method: "wallet_getCallsStatus",
-      params: [bundleId]
-    });
-    const result = raw;
-    const status = result.status;
-    console.info(`[swype-sdk][upgrade] ${label} status:`, status);
-    if (status === 200 || status === "CONFIRMED" || status === "confirmed") {
-      const txHash = result.receipts?.[0]?.transactionHash ?? "";
-      if (!txHash) {
-        console.warn(`[swype-sdk][upgrade] ${label}: confirmed but no receipt txHash.`);
-      }
-      return txHash;
-    }
-    if (typeof status === "number" && status >= 400) {
-      throw new Error(
-        `${label} failed with status ${status}. Receipts: ${JSON.stringify(result.receipts ?? [])}`
-      );
-    }
-    if (typeof status === "string" && (status.toLowerCase().includes("fail") || status.toLowerCase().includes("error"))) {
-      throw new Error(
-        `${label} failed: ${status}. Receipts: ${JSON.stringify(result.receipts ?? [])}`
-      );
-    }
-    await sleep(intervalMs);
-  }
-  throw new Error(`${label} timed out after ${timeoutMs / 1e3}s.`);
-}
-async function sendCalls(client, callsParams, label) {
-  try {
-    const result = await client.request({
-      method: "wallet_sendCalls",
-      params: [callsParams]
-    });
-    const bundleId = typeof result === "string" ? result : result?.id;
-    if (!bundleId) {
-      throw new Error(`${label}: wallet_sendCalls returned an unexpected result: ${JSON.stringify(result)}`);
-    }
-    return bundleId;
-  } catch (err) {
-    const msg = err.message ?? "";
-    if (msg.includes("Unauthorized") || msg.includes("-32006")) {
-      throw new Error(
-        "MetaMask smart accounts may not be enabled or may not be supported on this chain. Please ensure you are using a supported network and that smart accounts are enabled in MetaMask Settings \u2192 Experimental."
-      );
-    }
-    throw new Error(`${label} failed: ${msg}`);
-  }
-}
-async function submitUpgradeTransaction(params) {
-  const { walletClient, sender, metadata } = params;
-  const addKeyCalldata = metadata?.addKeyCalldata;
-  if (!isNonEmptyString(addKeyCalldata)) {
-    throw new Error("Incomplete upgrade metadata: missing addKeyCalldata.");
-  }
-  const resolvedSmartAccountAddress = metadata?.smartAccountAddress ?? sender;
-  if (!isNonEmptyString(resolvedSmartAccountAddress)) {
-    throw new Error("No connected account address found for smart account upgrade.");
-  }
-  const chainId = metadata?.upgradePayload?.authorization?.chainId;
-  if (!isValidChainId(chainId)) {
-    throw new Error("Invalid or missing chainId in upgrade metadata.");
-  }
-  if (!isRpcClient(walletClient)) {
-    throw new Error(
-      "Connected wallet client does not support request(). EIP-7702 upgrade requires a wallet client with raw RPC access."
-    );
-  }
-  const hexChainId = `0x${chainId.toString(16)}`;
-  console.info(
-    "[swype-sdk][upgrade] Step 1/2: Triggering EIP-7702 upgrade via wallet_sendCalls.",
-    { from: resolvedSmartAccountAddress, chainId: hexChainId }
-  );
-  const upgradeBundleId = await sendCalls(
-    walletClient,
-    {
-      version: "2.0.0",
-      from: resolvedSmartAccountAddress,
-      chainId: hexChainId,
-      atomicRequired: false,
-      calls: [{ to: resolvedSmartAccountAddress, value: "0x0" }]
-    },
-    "EIP-7702 upgrade"
-  );
-  console.info("[swype-sdk][upgrade] Upgrade bundle submitted. Polling for confirmation\u2026", {
-    bundleId: upgradeBundleId
-  });
-  const upgradeTxHash = await pollCallsStatus(
-    walletClient,
-    upgradeBundleId,
-    "EIP-7702 upgrade"
-  );
-  console.info("[swype-sdk][upgrade] Step 1/2 complete: account upgraded.", {
-    txHash: upgradeTxHash
-  });
-  console.info(
-    "[swype-sdk][upgrade] Step 2/2: Registering passkey via wallet_sendCalls (addKey)."
-  );
-  const addKeyBundleId = await sendCalls(
-    walletClient,
-    {
-      version: "2.0.0",
-      from: resolvedSmartAccountAddress,
-      chainId: hexChainId,
-      atomicRequired: false,
-      calls: [
-        {
-          to: resolvedSmartAccountAddress,
-          value: "0x0",
-          data: addKeyCalldata
-        }
-      ]
-    },
-    "Passkey registration (addKey)"
-  );
-  console.info("[swype-sdk][upgrade] addKey bundle submitted. Polling for confirmation\u2026", {
-    bundleId: addKeyBundleId
-  });
-  const addKeyTxHash = await pollCallsStatus(
-    walletClient,
-    addKeyBundleId,
-    "Passkey registration"
-  );
-  console.info("[swype-sdk][upgrade] Step 2/2 complete: passkey registered.", {
-    txHash: addKeyTxHash
-  });
-  return {
-    txHash: addKeyTxHash || upgradeTxHash,
-    smartAccountAddress: resolvedSmartAccountAddress
-  };
-}
-
-// src/hooks.ts
-async function waitForWalletClient(wagmiConfig2, maxAttempts = 15, intervalMs = 200) {
+async function waitForWalletClient(wagmiConfig2, walletClientParams = {}, maxAttempts = 15, intervalMs = 200) {
   for (let i = 0; i < maxAttempts; i++) {
     try {
-      return await getWalletClient(wagmiConfig2);
+      return await getWalletClient(wagmiConfig2, walletClientParams);
     } catch {
       if (i === maxAttempts - 1) {
         throw new Error("Wallet not ready. Please try again.");
@@ -690,19 +540,29 @@ async function waitForWalletClient(wagmiConfig2, maxAttempts = 15, intervalMs =
   }
   throw new Error("Wallet not ready. Please try again.");
 }
-function extractErrorMessage(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  if (err && typeof err === "object") {
-    const maybeMessage = err.message;
-    if (typeof maybeMessage === "string") return maybeMessage;
+function parseSignTypedDataPayload(typedData) {
+  const domain = typedData.domain;
+  const types = typedData.types;
+  const primaryType = typedData.primaryType;
+  const message = typedData.message;
+  if (!domain || typeof domain !== "object" || Array.isArray(domain)) {
+    throw new Error("SIGN_PERMIT2 typedData is missing a valid domain object.");
   }
-  return "Failed to upgrade account";
-}
-function isMetaMaskConnector(account) {
-  const connectorName = account.connector?.name?.toLowerCase() ?? "";
-  const connectorId = account.connector?.id?.toLowerCase() ?? "";
-  return connectorName.includes("metamask") || connectorId.includes("metamask");
+  if (!types || typeof types !== "object" || Array.isArray(types)) {
+    throw new Error("SIGN_PERMIT2 typedData is missing a valid types object.");
+  }
+  if (typeof primaryType !== "string") {
+    throw new Error("SIGN_PERMIT2 typedData is missing primaryType.");
+  }
+  if (!message || typeof message !== "object" || Array.isArray(message)) {
+    throw new Error("SIGN_PERMIT2 typedData is missing a valid message object.");
+  }
+  return {
+    domain,
+    types,
+    primaryType,
+    message
+  };
 }
 function useTransferPolling(intervalMs = 3e3) {
   const { apiBaseUrl } = useSwypeConfig();
@@ -974,88 +834,180 @@ function useAuthorizationExecutor() {
     },
     [wagmiConfig2]
   );
-  const executeUpgradeSmartAccount = react.useCallback(
+  const executeCreateSmartAccount = react.useCallback(
+    async (action) => {
+      return {
+        actionId: action.id,
+        type: action.type,
+        status: "success",
+        message: "Smart account creation acknowledged. Server is deploying.",
+        data: {}
+      };
+    },
+    []
+  );
+  const executeApprovePermit2 = react.useCallback(
     async (action) => {
       try {
-        const account = getAccount(wagmiConfig2);
         const walletClient = await waitForWalletClient(wagmiConfig2);
+        const account = getAccount(wagmiConfig2);
         const sender = account.address ?? walletClient.account?.address;
+        const expectedWalletAddress = action.metadata?.walletAddress;
         if (!sender) {
           throw new Error("Wallet account not available. Please connect your wallet.");
         }
-        if (!isMetaMaskConnector(account)) {
-          throw new Error(
-            "EIP-7702 smart account upgrade requires a MetaMask-compatible wallet. Please reconnect using MetaMask and try again."
-          );
+        if (expectedWalletAddress && sender.toLowerCase() !== expectedWalletAddress.toLowerCase()) {
+          return {
+            actionId: action.id,
+            type: action.type,
+            status: "error",
+            message: `Connected wallet ${sender} does not match the required source wallet ${expectedWalletAddress}. Please switch accounts in your wallet and retry.`
+          };
         }
-        const metadata = action.metadata;
-        const { txHash, smartAccountAddress } = await submitUpgradeTransaction({
-          walletClient,
-          sender,
-          metadata
+        const to = action.metadata?.to;
+        const data = action.metadata?.data;
+        const tokenSymbol = action.metadata?.tokenSymbol;
+        if (!to || !data) {
+          return {
+            actionId: action.id,
+            type: action.type,
+            status: "error",
+            message: "APPROVE_PERMIT2 metadata is missing transaction parameters (to, data)."
+          };
+        }
+        const txHash = await walletClient.request({
+          method: "eth_sendTransaction",
+          params: [
+            {
+              from: sender,
+              to,
+              data,
+              value: "0x0"
+            }
+          ]
         });
+        console.info(
+          `[swype-sdk][approve-permit2] ERC-20 approve tx sent. token=${tokenSymbol ?? to}, txHash=${txHash}`
+        );
         return {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: "Account upgrade transaction submitted.",
-          data: {
-            txHash,
-            smartAccountAddress
-          }
+          message: `Approved Permit2 to spend ${tokenSymbol ?? "tokens"}.`,
+          data: { txHash }
         };
       } catch (err) {
-        console.error("Failed to upgrade account", err);
-        const message = extractErrorMessage(err);
+        const message = err instanceof Error ? err.message : "Failed to approve Permit2";
         const isRejected = message.includes("rejected") || message.includes("denied") || message.includes("user rejected");
         return {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: isRejected ? "You rejected the upgrade transaction. Please approve the transaction prompt in your wallet to continue." : message
+          message: isRejected ? "You rejected the approval transaction. Please approve the Permit2 spending allowance in your wallet to continue." : message
         };
       }
     },
     [wagmiConfig2]
   );
-  const executeGrantPermissions = react.useCallback(
+  const executeSignPermit2 = react.useCallback(
     async (action) => {
       try {
-        const walletClient = await waitForWalletClient(wagmiConfig2);
-        const signingPayload = action.metadata?.signingPayload;
-        const tokens = action.metadata?.tokens;
-        if (!signingPayload) {
+        const expectedWalletAddress = action.metadata?.walletAddress;
+        const walletClient = await waitForWalletClient(
+          wagmiConfig2,
+          expectedWalletAddress ? { account: expectedWalletAddress } : {}
+        );
+        const account = getAccount(wagmiConfig2);
+        const connectedAddress = account.address ?? walletClient.account?.address;
+        const sender = expectedWalletAddress ?? connectedAddress;
+        if (!sender) {
+          throw new Error("Wallet account not available. Please connect your wallet.");
+        }
+        if (expectedWalletAddress && connectedAddress && connectedAddress.toLowerCase() !== expectedWalletAddress.toLowerCase()) {
+          return {
+            actionId: action.id,
+            type: action.type,
+            status: "error",
+            message: `Connected wallet ${sender} does not match the required source wallet ${expectedWalletAddress}. Please switch accounts in your wallet and retry.`
+          };
+        }
+        let typedData = action.metadata?.typedData;
+        const tokenSymbol = action.metadata?.tokenSymbol;
+        if (!typedData && sessionIdRef.current) {
+          const POLL_INTERVAL_MS = 1e3;
+          const MAX_POLLS = 15;
+          for (let i = 0; i < MAX_POLLS; i++) {
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+            const session = await fetchAuthorizationSession(
+              apiBaseUrl,
+              sessionIdRef.current
+            );
+            const updatedAction = session.actions.find((a) => a.id === action.id);
+            typedData = updatedAction?.metadata?.typedData;
+            if (typedData) break;
+          }
+        }
+        if (!typedData) {
           return {
             actionId: action.id,
             type: action.type,
             status: "error",
-            message: "No signing payload in action metadata."
+            message: "SIGN_PERMIT2 metadata is missing typedData. The server may still be preparing the signing payload."
           };
         }
-        const signature = await walletClient.signMessage({
-          message: JSON.stringify(signingPayload)
+        const parsedTypedData = parseSignTypedDataPayload(typedData);
+        console.info(
+          `[swype-sdk][sign-permit2] Signing typed data. expectedOwner=${expectedWalletAddress ?? "N/A"}, senderParam=${sender}, connectedAddress=${connectedAddress ?? "N/A"}, primaryType=${parsedTypedData.primaryType}, domainChainId=${String(parsedTypedData.domain.chainId ?? "N/A")}, verifyingContract=${String(parsedTypedData.domain.verifyingContract ?? "N/A")}`
+        );
+        const signature = await walletClient.signTypedData({
+          account: sender,
+          domain: parsedTypedData.domain,
+          types: parsedTypedData.types,
+          primaryType: parsedTypedData.primaryType,
+          message: parsedTypedData.message
         });
-        const tokenSummary = tokens?.map((t) => `${t.symbol} on ${t.chainName}`).join(", ") ?? "all tokens";
+        const recoverInput = {
+          domain: parsedTypedData.domain,
+          types: parsedTypedData.types,
+          primaryType: parsedTypedData.primaryType,
+          message: parsedTypedData.message,
+          signature
+        };
+        const recoveredSigner = await viem.recoverTypedDataAddress(recoverInput);
+        const expectedSigner = (expectedWalletAddress ?? sender).toLowerCase();
+        console.info(
+          `[swype-sdk][sign-permit2] Signature recovered. recoveredSigner=${recoveredSigner}, expectedSigner=${expectedSigner}`
+        );
+        if (recoveredSigner.toLowerCase() !== expectedSigner) {
+          return {
+            actionId: action.id,
+            type: action.type,
+            status: "error",
+            message: `Wallet signed with ${recoveredSigner}, but source wallet is ${expectedWalletAddress ?? sender}. Please switch to the source wallet in MetaMask and retry.`
+          };
+        }
+        console.info(
+          `[swype-sdk][sign-permit2] Permit2 EIP-712 signature obtained. token=${tokenSymbol ?? "unknown"}`
+        );
         return {
           actionId: action.id,
           type: action.type,
           status: "success",
-          message: `Permissions granted for ${tokenSummary}.`,
-          data: {
-            signedDelegation: signature,
-            tokens
-          }
+          message: `Permit2 allowance signed for ${tokenSymbol ?? "tokens"}.`,
+          data: { signature }
         };
       } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to sign Permit2 allowance";
+        const isRejected = message.includes("rejected") || message.includes("denied") || message.includes("user rejected");
         return {
           actionId: action.id,
           type: action.type,
           status: "error",
-          message: err instanceof Error ? err.message : "Failed to grant permissions"
+          message: isRejected ? "You rejected the Permit2 signature request. Please approve the signature in your wallet to allow fund transfers." : message
         };
       }
     },
-    [wagmiConfig2]
+    [wagmiConfig2, apiBaseUrl]
   );
   const executeAction = react.useCallback(
     async (action) => {
@@ -1069,10 +1021,12 @@ function useAuthorizationExecutor() {
           return executeSwitchChain(action);
         case "REGISTER_PASSKEY":
           return executeRegisterPasskey(action);
-        case "UPGRADE_SMART_ACCOUNT":
-          return executeUpgradeSmartAccount(action);
-        case "GRANT_PERMISSIONS":
-          return executeGrantPermissions(action);
+        case "CREATE_SMART_ACCOUNT":
+          return executeCreateSmartAccount(action);
+        case "APPROVE_PERMIT2":
+          return executeApprovePermit2(action);
+        case "SIGN_PERMIT2":
+          return executeSignPermit2(action);
         default:
           return {
             actionId: action.id,
@@ -1082,7 +1036,7 @@ function useAuthorizationExecutor() {
           };
       }
     },
-    [executeOpenProvider, executeSelectSource, executeSwitchChain, executeRegisterPasskey, executeUpgradeSmartAccount, executeGrantPermissions]
+    [executeOpenProvider, executeSelectSource, executeSwitchChain, executeRegisterPasskey, executeCreateSmartAccount, executeApprovePermit2, executeSignPermit2]
   );
   const executeSession = react.useCallback(
     async (transfer) => {
@@ -2783,15 +2737,20 @@ function SwypePayment({
             label: "Creating your passkey...",
             description: "Set up a passkey for secure, one-touch payments."
           };
-        case "UPGRADE_SMART_ACCOUNT":
+        case "CREATE_SMART_ACCOUNT":
+          return {
+            label: "Creating your smart account...",
+            description: "Setting up your smart account for gasless payments."
+          };
+        case "APPROVE_PERMIT2":
           return {
-            label: "Upgrading your account...",
-            description: "Approve the prompts in MetaMask to upgrade your account to a smart account and register your passkey. You may see two prompts."
+            label: "Approving token access...",
+            description: "Approve the prompt in your wallet to allow secure token transfers."
           };
-        case "GRANT_PERMISSIONS":
+        case "SIGN_PERMIT2":
           return {
-            label: "Setting up permissions...",
-            description: "Signing delegation permissions. Transfer routing and gas sponsorship are handled by Swype backend."
+            label: "Signing transfer permission...",
+            description: "Sign the permit to allow your smart account to transfer tokens on your behalf."
           };
         default:
           return { label: "", description: "" };