@getpara/wagmi-v2-integration 1.4.4-dev.1 → 1.4.4-dev.3

package/dist/index.js

@@ -1,3 +1,348 @@
 "use client";
-export * from "./paraConnector.js";
-export * from "./ParaEIP1193Provider.js";
+
+// src/paraConnector.ts
+import { injected } from "wagmi/connectors";
+
+// src/ParaEIP1193Provider.ts
+import {
+  ProviderRpcError,
+  webSocket,
+  publicActions,
+  http,
+  formatTransaction
+} from "viem";
+import { EventEmitter } from "eventemitter3";
+import { extractRpcUrls } from "@wagmi/core";
+import { getViemChain, createParaViemClient, createParaAccount } from "@getpara/viem-v2-integration";
+import { decimalToHex, hexToDecimal } from "@getpara/react-sdk";
+
+// src/connectorModal.tsx
+import { ParaModal } from "@getpara/react-sdk";
+import { jsx } from "react/jsx-runtime";
+function renderModal(para, modalProps, onCloseArg) {
+  const existingContainer = document.getElementById("para-modal");
+  const container = existingContainer ?? document.createElement("div");
+  container.id = "para-modal";
+  if (!existingContainer) {
+    document.body.appendChild(container);
+  }
+  const onClose = () => {
+    onCloseArg();
+    modalProps.onClose && modalProps.onClose();
+    render(false);
+  };
+  const render = async (isOpen) => {
+    const Modal = /* @__PURE__ */ jsx(ParaModal, { ...modalProps, onClose, para, isOpen });
+    try {
+      const client = await import("react-dom/client");
+      const root = client.createRoot(container);
+      root.render(Modal);
+    } catch (e) {
+      const ReactDOM = await import("react-dom");
+      ReactDOM.render(Modal, container);
+    }
+  };
+  render(true);
+}
+
+// src/ParaEIP1193Provider.ts
+var STORAGE_CHAIN_ID_KEY = "@CAPSULE/chainId";
+var TEN_MINUTES_MS = 6e5;
+var serverSessionStorageStub = {
+  setItem: () => {
+  },
+  getItem: () => null
+};
+var ParaEIP1193Provider = class extends EventEmitter {
+  constructor(opts) {
+    super();
+    this.getRpcUrlsFromViemChain = (chain) => {
+      return extractRpcUrls({ chain, transports: this.transports });
+    };
+    this.wagmiChainToAddEthereumChainParameters = (chain) => {
+      const hexChainId = decimalToHex(`${chain.id}`);
+      return [
+        hexChainId,
+        {
+          chainId: hexChainId,
+          chainName: chain.name,
+          nativeCurrency: chain.nativeCurrency,
+          rpcUrls: this.getRpcUrlsFromViemChain(chain)
+        }
+      ];
+    };
+    this.wagmiChainsToAddEthereumChainParameters = (chains) => {
+      return Object.fromEntries(chains.map(this.wagmiChainToAddEthereumChainParameters));
+    };
+    this.accountFromAddress = (address) => {
+      return createParaAccount(this.para, address);
+    };
+    this.setCurrentChain = (chainId) => {
+      const chain = this.chains[chainId];
+      this.setChainId(chainId);
+      const viemChain = this.viemChains[chainId] || getViemChain(hexToDecimal(chainId));
+      const rpcUrls = this.getRpcUrlsFromViemChain(viemChain);
+      let transport;
+      if (this.transports[viemChain.id]) {
+        transport = this.transports[viemChain.id];
+      } else if (rpcUrls[0].startsWith("ws")) {
+        transport = webSocket(chain.rpcUrls[0]);
+      } else {
+        transport = http(rpcUrls[0]);
+        this.chainTransportSubscribe = void 0;
+      }
+      const chainTransport = transport({
+        chain: viemChain
+      });
+      if (chainTransport.config.type === "ws") {
+        this.chainTransportSubscribe = chainTransport.value.subscribe;
+      }
+      this.walletClient = createParaViemClient(
+        this.para,
+        {
+          chain: viemChain,
+          transport
+          // @ts-ignore
+        },
+        { noAccount: true }
+      ).extend(publicActions);
+      this.emit("chainChanged", this.currentHexChainId);
+    };
+    this.closeModal = () => {
+      this.isModalClosed = true;
+    };
+    this.request = async (args) => {
+      const { method, params } = args;
+      switch (method) {
+        case "eth_accounts": {
+          const accounts = this.accounts;
+          return accounts || [];
+        }
+        case "eth_chainId": {
+          return this.currentHexChainId;
+        }
+        case "eth_requestAccounts": {
+          if (await this.para.isFullyLoggedIn()) {
+            const accounts = this.accounts;
+            if (accounts && accounts.length > 0) {
+              return accounts;
+            }
+          }
+          if (!this.disableModal) {
+            this.isModalClosed = false;
+            renderModal(this.para, this.modalProps, () => {
+              this.isModalClosed = true;
+            });
+          }
+          await this.waitForLogin();
+          try {
+            const accounts = await this.waitForAccounts();
+            this.emit("accountsChanged", accounts);
+            return accounts;
+          } catch (error) {
+            throw new ProviderRpcError(new Error("accounts not available after login"), {
+              code: 4001,
+              shortMessage: "accounts not available after login"
+            });
+          }
+        }
+        case "eth_sendTransaction": {
+          const fromAddress = params[0].from;
+          return this.walletClient.sendTransaction({
+            ...formatTransaction(params[0]),
+            chain: void 0,
+            // uses the chain from the wallet client
+            account: this.accountFromAddress(fromAddress)
+          });
+        }
+        case "eth_sign":
+        case "personal_sign": {
+          return this.walletClient.signMessage({
+            message: { raw: params[0] },
+            account: this.accountFromAddress(params[1])
+          });
+        }
+        case "eth_signTransaction": {
+          const fromAddress = params[0].from;
+          return this.accountFromAddress(fromAddress).signTransaction(formatTransaction(params[0]));
+        }
+        case "eth_signTypedData_v4": {
+          const fromAddress = params[0];
+          let typedMessage = params[1];
+          if (typeof typedMessage === "string") {
+            typedMessage = JSON.parse(typedMessage);
+          }
+          return this.walletClient.signTypedData({
+            ...typedMessage,
+            account: this.accountFromAddress(fromAddress)
+          });
+        }
+        case "eth_subscribe": {
+          if (!this.chainTransportSubscribe) {
+            throw new ProviderRpcError(new Error("chain does not support subscriptions"), {
+              code: 4200,
+              shortMessage: "chain does not support subscriptions"
+            });
+          }
+          const res = await this.chainTransportSubscribe({
+            params,
+            onData: (data) => {
+              this.emit("message", {
+                type: "eth_subscription",
+                data
+              });
+            }
+          });
+          return res.subscriptionId;
+        }
+        case "wallet_addEthereumChain": {
+          if (!this.chains[params[0].chainId]) {
+            this.chains[params[0].chainId] = params[0];
+          }
+          return null;
+        }
+        case "wallet_getPermissions": {
+          return [];
+        }
+        case "wallet_requestPermissions": {
+          return [];
+        }
+        case "wallet_switchEthereumChain": {
+          if (!this.chains[params[0].chainId]) {
+            const chain = getViemChain(hexToDecimal(params[0].chainId));
+            const [hexChainId, addEthereumChainParameter] = this.wagmiChainToAddEthereumChainParameters(chain);
+            this.chains[hexChainId] = addEthereumChainParameter;
+            this.setCurrentChain(params[0].chainId);
+          }
+          if (this.currentHexChainId !== params[0].chainId) {
+            this.setCurrentChain(params[0].chainId);
+          }
+          return null;
+        }
+        case "wallet_watchAsset": {
+          return false;
+        }
+        default: {
+          return this.walletClient.request({
+            method,
+            params
+          });
+        }
+      }
+    };
+    this.storage = opts.storageOverride || typeof window === "undefined" ? serverSessionStorageStub : sessionStorage;
+    this.isModalClosed = true;
+    this.para = opts.para;
+    this.modalProps = { ...opts };
+    this.disableModal = !!opts.disableModal;
+    this.viemChains = opts.chains.reduce((acc, curChain) => {
+      acc[decimalToHex(`${curChain.id}`)] = curChain;
+      return acc;
+    }, {});
+    this.chains = this.wagmiChainsToAddEthereumChainParameters(opts.chains);
+    this.transports = opts.transports;
+    const defaultChainId = this.getStorageChainId() || opts.chainId;
+    const currentChainId = this.chains[decimalToHex(defaultChainId)] ? defaultChainId : `${opts.chains[0].id}`;
+    this.setCurrentChain(decimalToHex(currentChainId));
+    this.emit("connect", { chainId: this.currentHexChainId });
+  }
+  get accounts() {
+    return this.para.getWalletsByType("EVM").map((w) => w.address);
+  }
+  getStorageChainId() {
+    return this.storage.getItem(STORAGE_CHAIN_ID_KEY);
+  }
+  setChainId(hexChainId) {
+    this.currentHexChainId = hexChainId;
+    this.storage.setItem(STORAGE_CHAIN_ID_KEY, hexToDecimal(hexChainId));
+  }
+  async waitForLogin(timeoutMs = TEN_MINUTES_MS) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      if (await this.para.isFullyLoggedIn()) {
+        return true;
+      }
+      if (this.isModalClosed) {
+        throw new ProviderRpcError(new Error("user closed modal"), {
+          code: 4001,
+          shortMessage: "user closed modal"
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+    }
+    throw new ProviderRpcError(new Error("timed out waiting for user to log in"), {
+      code: 4900,
+      //provider is disconnected code
+      shortMessage: "timed out waiting for user to log in"
+    });
+  }
+  async waitForAccounts(timeoutMs = 5e3) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const accounts = this.accounts;
+      if (accounts && accounts.length > 0) {
+        return accounts;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new ProviderRpcError(new Error("timed out waiting for accounts to load"), {
+      code: 4900,
+      //provider is disconnected code
+      shortMessage: "timed out waiting for accounts to load"
+    });
+  }
+};
+
+// src/paraConnector.ts
+import { createConnector } from "wagmi";
+var PARA_ID = "para";
+var PARA_NAME = "Para";
+var PARA_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjE2IiBoZWlnaHQ9IjIwNCIgdmlld0JveD0iMCAwIDIxNiAyMDQiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik02MCAwSDE0NEMxODMuNzY0IDAgMjE2IDMyLjIzNTUgMjE2IDcyQzIxNiAxMTEuNzY1IDE4My43NjQgMTQ0IDE0NCAxNDRIOTZDODIuNzQ1MiAxNDQgNzIgMTU0Ljc0NSA3MiAxNjhWMjA0SDBWMTMySDM2QzQ5LjI1NDggMTMyIDYwIDEyMS4yNTUgNjAgMTA4TDYwIDBaIiBmaWxsPSJibGFjayIvPgo8L3N2Zz4K";
+var paraConnector = ({
+  para,
+  chains: _chains,
+  disableModal,
+  storageOverride,
+  options,
+  iconOverride,
+  nameOverride,
+  idOverride,
+  transports,
+  ...modalProps
+}) => {
+  return createConnector((config) => {
+    const chains = [...config.chains];
+    const eip1193Provider = new ParaEIP1193Provider({
+      para,
+      chainId: `${chains[0].id}`,
+      chains,
+      disableModal,
+      storageOverride,
+      transports: transports || config.transports,
+      ...modalProps
+    });
+    const injectedObj = injected({
+      target: {
+        name: PARA_NAME,
+        id: idOverride ?? PARA_ID,
+        provider: eip1193Provider
+      },
+      ...options
+    })(config);
+    return {
+      ...injectedObj,
+      type: idOverride ?? PARA_ID,
+      name: nameOverride ?? PARA_NAME,
+      icon: iconOverride ?? PARA_ICON,
+      disconnect: async () => {
+        eip1193Provider.closeModal();
+        await injectedObj.disconnect();
+        para.logout();
+      }
+    };
+  });
+};
+export {
+  ParaEIP1193Provider,
+  paraConnector
+};

package/dist/paraConnector.d.ts

@@ -21,17 +21,17 @@ export declare const paraConnector: ({ para, chains: _chains, disableModal, stor
     type: string;
     name: string;
     icon: string;
-    connect: (parameters: {
+    disconnect: () => Promise<void>;
+    id: string;
+    supportsSimulation?: boolean;
+    setup?: () => Promise<void>;
+    connect: (parameters?: {
         chainId?: number;
         isReconnecting?: boolean;
     }) => Promise<{
         accounts: readonly `0x${string}`[];
         chainId: number;
     }>;
-    disconnect: () => Promise<void>;
-    id: string;
-    supportsSimulation?: boolean;
-    setup?: () => Promise<void>;
     getAccounts: () => Promise<readonly `0x${string}`[]>;
     getChainId: () => Promise<number>;
     getProvider: (parameters?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpara/wagmi-v2-integration",
-  "version": "1.4.4-dev.1",
+  "version": "1.4.4-dev.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",