@getpara/wagmi-v2-connector 2.0.0-alpha.60 → 2.0.0-alpha.61

package/dist/ParaEIP1193Provider.d.ts

@@ -0,0 +1,42 @@
+import { EIP1474Methods, EIP1193Provider, EIP1193RequestFn, Transport } from 'viem';
+import { EventEmitter } from 'eventemitter3';
+import { Chain } from 'wagmi/chains';
+import ParaWeb from '@getpara/web-sdk';
+interface ParaEIP1193ProviderOpts {
+    para: ParaWeb;
+    chainId: string;
+    chains: Chain[];
+    disableModal?: boolean;
+    storageOverride?: Pick<Storage, 'setItem' | 'getItem'>;
+    transports?: Record<number, Transport>;
+    renderModal?: (onClose: () => void) => {
+        openModal: () => void;
+    };
+}
+export declare class ParaEIP1193Provider extends EventEmitter implements EIP1193Provider {
+    private currentHexChainId;
+    private walletClient;
+    private chainTransportSubscribe?;
+    private chains;
+    private viemChains;
+    private para;
+    private disableModal;
+    private storage;
+    private isModalClosed;
+    private transports?;
+    private openModal?;
+    constructor(opts: ParaEIP1193ProviderOpts);
+    private get accounts();
+    private getStorageChainId;
+    private setChainId;
+    private getRpcUrlsFromViemChain;
+    private wagmiChainToAddEthereumChainParameters;
+    private wagmiChainsToAddEthereumChainParameters;
+    private accountFromAddress;
+    private setCurrentChain;
+    closeModal: () => void;
+    private waitForLogin;
+    private waitForAccounts;
+    request: EIP1193RequestFn<EIP1474Methods>;
+}
+export {};

package/dist/ParaEIP1193Provider.js

@@ -0,0 +1,268 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-IV3L3JVM.js";
+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/web-sdk";
+const STORAGE_CHAIN_ID_KEY = "@CAPSULE/chainId";
+const TEN_MINUTES_MS = 6e5;
+const serverSessionStorageStub = {
+  setItem: () => {
+  },
+  getItem: () => null
+};
+class ParaEIP1193Provider 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 = (args) => __async(this, null, function* () {
+      var _a;
+      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 (yield this.para.isFullyLoggedIn()) {
+            const accounts = this.accounts;
+            if (accounts && accounts.length > 0) {
+              return accounts;
+            }
+          }
+          this.isModalClosed = false;
+          (_a = this.openModal) == null ? void 0 : _a.call(this);
+          yield this.waitForLogin();
+          try {
+            const accounts = yield 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(__spreadProps(__spreadValues({}, 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(__spreadProps(__spreadValues({}, 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 = yield 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.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;
+    if (!this.disableModal && opts.renderModal) {
+      const { openModal } = opts.renderModal(this.closeModal);
+      this.openModal = openModal;
+    }
+    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));
+  }
+  waitForLogin() {
+    return __async(this, arguments, function* (timeoutMs = TEN_MINUTES_MS) {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeoutMs) {
+        if (yield this.para.isFullyLoggedIn()) {
+          return true;
+        }
+        if (!this.disableModal && this.isModalClosed) {
+          throw new ProviderRpcError(new Error("user closed modal"), {
+            code: 4001,
+            shortMessage: "user closed modal"
+          });
+        }
+        yield 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"
+      });
+    });
+  }
+  waitForAccounts(timeoutMs = 5e3) {
+    return __async(this, null, function* () {
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeoutMs) {
+        const accounts = this.accounts;
+        if (accounts && accounts.length > 0) {
+          return accounts;
+        }
+        yield 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"
+      });
+    });
+  }
+}
+export {
+  ParaEIP1193Provider
+};

package/dist/chunk-IV3L3JVM.js

@@ -0,0 +1,46 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __async
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './paraConnector.js';
+export * from './ParaEIP1193Provider.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+"use client";
+export * from "./paraConnector.js";
+export * from "./ParaEIP1193Provider.js";

package/dist/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}

package/dist/paraConnector.d.ts

@@ -0,0 +1,325 @@
+import { Chain } from 'wagmi/chains';
+import { InjectedParameters } from 'wagmi/connectors';
+import ParaWeb from '@getpara/web-sdk';
+import { Transport } from 'viem';
+export interface ParaConnectorOpts {
+    /**
+     * @deprecated Use `chains` in the wagmi config instead.
+     */
+    chains?: Chain[];
+    options: InjectedParameters;
+    para: ParaWeb;
+    disableModal?: boolean;
+    appName: string;
+    idOverride?: string;
+    storageOverride?: Pick<Storage, 'setItem' | 'getItem'>;
+    iconOverride?: string;
+    nameOverride?: string;
+    transports?: Record<number, Transport>;
+}
+export declare const createParaConnector: ({ para, chains: _chains, disableModal, storageOverride, options, iconOverride, nameOverride, idOverride, transports, renderModal, }: ParaConnectorOpts & {
+    renderModal?: (onClose: () => void) => {
+        openModal: () => void;
+    };
+}) => (config: {
+    chains: readonly [Chain, ...Chain[]];
+    emitter: import("@wagmi/core/internal").Emitter<import("wagmi").ConnectorEventMap>;
+    storage?: {
+        key: string;
+        getItem: <key_1 extends string, value extends (import("@wagmi/core").StorageItemMap & Record<string, unknown>)[key_1], defaultValue_1 extends value>(key: key_1, defaultValue?: defaultValue_1) => (defaultValue_1 extends null ? value : value) | Promise<defaultValue_1 extends null ? value : value>;
+        setItem: <key_1 extends string, value_1 extends (import("@wagmi/core").StorageItemMap & Record<string, unknown>)[key_1]>(key: key_1, value: value_1) => void | Promise<void>;
+        removeItem: (key: string) => void | Promise<void>;
+    };
+    transports?: Record<number, import("wagmi").Transport> | undefined;
+}) => {
+    type: string;
+    name: string;
+    icon: string;
+    disconnect: () => Promise<void>;
+    id: string;
+    rdns?: string | readonly string[] | undefined;
+    supportsSimulation?: boolean | undefined;
+    setup?: () => Promise<void>;
+    connect: (parameters?: {
+        chainId?: number | undefined;
+        isReconnecting?: boolean | undefined;
+    } | undefined) => Promise<{
+        accounts: readonly import("viem").Address[];
+        chainId: number;
+    }>;
+    getAccounts: () => Promise<readonly import("viem").Address[]>;
+    getChainId: () => Promise<number>;
+    getProvider: (parameters?: {
+        chainId?: number | undefined;
+    } | undefined) => Promise<{
+        on: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+        removeListener: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+        request: import("viem").EIP1193RequestFn<import("viem").EIP1474Methods>;
+        isApexWallet?: true | undefined;
+        isAvalanche?: true | undefined;
+        isBackpack?: true | undefined;
+        isBifrost?: true | undefined;
+        isBitKeep?: true | undefined;
+        isBitski?: true | undefined;
+        isBlockWallet?: true | undefined;
+        isBraveWallet?: true | undefined;
+        isCoinbaseWallet?: true | undefined;
+        isDawn?: true | undefined;
+        isEnkrypt?: true | undefined;
+        isExodus?: true | undefined;
+        isFrame?: true | undefined;
+        isFrontier?: true | undefined;
+        isGamestop?: true | undefined;
+        isHyperPay?: true | undefined;
+        isImToken?: true | undefined;
+        isKuCoinWallet?: true | undefined;
+        isMathWallet?: true | undefined;
+        isMetaMask?: true | undefined;
+        isOkxWallet?: true | undefined;
+        isOKExWallet?: true | undefined;
+        isOneInchAndroidWallet?: true | undefined;
+        isOneInchIOSWallet?: true | undefined;
+        isOpera?: true | undefined;
+        isPhantom?: true | undefined;
+        isPortal?: true | undefined;
+        isRabby?: true | undefined;
+        isRainbow?: true | undefined;
+        isStatus?: true | undefined;
+        isTally?: true | undefined;
+        isTokenPocket?: true | undefined;
+        isTokenary?: true | undefined;
+        isTrust?: true | undefined;
+        isTrustWallet?: true | undefined;
+        isUniswapWallet?: true | undefined;
+        isXDEFI?: true | undefined;
+        isZerion?: true | undefined;
+        providers?: {
+            on: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+            removeListener: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+            request: import("viem").EIP1193RequestFn<import("viem").EIP1474Methods>;
+            isApexWallet?: true;
+            isAvalanche?: true;
+            isBackpack?: true;
+            isBifrost?: true;
+            isBitKeep?: true;
+            isBitski?: true;
+            isBlockWallet?: true;
+            isBraveWallet?: true;
+            isCoinbaseWallet?: true;
+            isDawn?: true;
+            isEnkrypt?: true;
+            isExodus?: true;
+            isFrame?: true;
+            isFrontier?: true;
+            isGamestop?: true;
+            isHyperPay?: true;
+            isImToken?: true;
+            isKuCoinWallet?: true;
+            isMathWallet?: true;
+            isMetaMask?: true;
+            isOkxWallet?: true;
+            isOKExWallet?: true;
+            isOneInchAndroidWallet?: true;
+            isOneInchIOSWallet?: true;
+            isOpera?: true;
+            isPhantom?: true;
+            isPortal?: true;
+            isRabby?: true;
+            isRainbow?: true;
+            isStatus?: true;
+            isTally?: true;
+            isTokenPocket?: true;
+            isTokenary?: true;
+            isTrust?: true;
+            isTrustWallet?: true;
+            isUniswapWallet?: true;
+            isXDEFI?: true;
+            isZerion?: true;
+            providers?: /*elided*/ any[];
+            _events?: {
+                connect?: (() => void) | undefined;
+            } | undefined;
+            _state?: {
+                accounts?: string[];
+                initialized?: boolean;
+                isConnected?: boolean;
+                isPermanentlyDisconnected?: boolean;
+                isUnlocked?: boolean;
+            } | undefined;
+        }[];
+        _events?: {
+            connect?: (() => void) | undefined;
+        } | undefined;
+        _state?: {
+            accounts?: string[];
+            initialized?: boolean;
+            isConnected?: boolean;
+            isPermanentlyDisconnected?: boolean;
+            isUnlocked?: boolean;
+        } | undefined;
+    }>;
+    getClient?: (parameters?: {
+        chainId?: number | undefined;
+    } | undefined) => Promise<import("viem").Client>;
+    isAuthorized: () => Promise<boolean>;
+    switchChain?: (parameters: import("@wagmi/core/internal").Compute<{
+        addEthereumChainParameter?: import("@wagmi/core/internal").ExactPartial<import("@wagmi/core/internal").Omit<import("viem").AddEthereumChainParameter, "chainId">> | undefined;
+        chainId: number;
+    }>) => Promise<Chain>;
+    onAccountsChanged: (accounts: string[]) => void;
+    onChainChanged: (chainId: string) => void;
+    onConnect: ((connectInfo: import("viem").ProviderConnectInfo) => void) & ((connectInfo: import("viem").ProviderConnectInfo) => void);
+    onDisconnect: (error?: Error | undefined) => void;
+    onMessage?: (message: import("viem").ProviderMessage) => void;
+};
+export declare const paraConnector: (opts: ParaConnectorOpts) => (config: {
+    chains: readonly [Chain, ...Chain[]];
+    emitter: import("@wagmi/core/internal").Emitter<import("wagmi").ConnectorEventMap>;
+    storage?: {
+        key: string;
+        getItem: <key_1 extends string, value extends (import("@wagmi/core").StorageItemMap & Record<string, unknown>)[key_1], defaultValue_1 extends value>(key: key_1, defaultValue?: defaultValue_1) => (defaultValue_1 extends null ? value : value) | Promise<defaultValue_1 extends null ? value : value>;
+        setItem: <key_1 extends string, value_1 extends (import("@wagmi/core").StorageItemMap & Record<string, unknown>)[key_1]>(key: key_1, value: value_1) => void | Promise<void>;
+        removeItem: (key: string) => void | Promise<void>;
+    };
+    transports?: Record<number, import("wagmi").Transport> | undefined;
+}) => {
+    type: string;
+    name: string;
+    icon: string;
+    disconnect: () => Promise<void>;
+    id: string;
+    rdns?: string | readonly string[] | undefined;
+    supportsSimulation?: boolean | undefined;
+    setup?: () => Promise<void>;
+    connect: (parameters?: {
+        chainId?: number | undefined;
+        isReconnecting?: boolean | undefined;
+    } | undefined) => Promise<{
+        accounts: readonly import("viem").Address[];
+        chainId: number;
+    }>;
+    getAccounts: () => Promise<readonly import("viem").Address[]>;
+    getChainId: () => Promise<number>;
+    getProvider: (parameters?: {
+        chainId?: number | undefined;
+    } | undefined) => Promise<{
+        on: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+        removeListener: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+        request: import("viem").EIP1193RequestFn<import("viem").EIP1474Methods>;
+        isApexWallet?: true | undefined;
+        isAvalanche?: true | undefined;
+        isBackpack?: true | undefined;
+        isBifrost?: true | undefined;
+        isBitKeep?: true | undefined;
+        isBitski?: true | undefined;
+        isBlockWallet?: true | undefined;
+        isBraveWallet?: true | undefined;
+        isCoinbaseWallet?: true | undefined;
+        isDawn?: true | undefined;
+        isEnkrypt?: true | undefined;
+        isExodus?: true | undefined;
+        isFrame?: true | undefined;
+        isFrontier?: true | undefined;
+        isGamestop?: true | undefined;
+        isHyperPay?: true | undefined;
+        isImToken?: true | undefined;
+        isKuCoinWallet?: true | undefined;
+        isMathWallet?: true | undefined;
+        isMetaMask?: true | undefined;
+        isOkxWallet?: true | undefined;
+        isOKExWallet?: true | undefined;
+        isOneInchAndroidWallet?: true | undefined;
+        isOneInchIOSWallet?: true | undefined;
+        isOpera?: true | undefined;
+        isPhantom?: true | undefined;
+        isPortal?: true | undefined;
+        isRabby?: true | undefined;
+        isRainbow?: true | undefined;
+        isStatus?: true | undefined;
+        isTally?: true | undefined;
+        isTokenPocket?: true | undefined;
+        isTokenary?: true | undefined;
+        isTrust?: true | undefined;
+        isTrustWallet?: true | undefined;
+        isUniswapWallet?: true | undefined;
+        isXDEFI?: true | undefined;
+        isZerion?: true | undefined;
+        providers?: {
+            on: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+            removeListener: <event extends keyof import("viem").EIP1193EventMap>(event: event, listener: import("viem").EIP1193EventMap[event]) => void;
+            request: import("viem").EIP1193RequestFn<import("viem").EIP1474Methods>;
+            isApexWallet?: true;
+            isAvalanche?: true;
+            isBackpack?: true;
+            isBifrost?: true;
+            isBitKeep?: true;
+            isBitski?: true;
+            isBlockWallet?: true;
+            isBraveWallet?: true;
+            isCoinbaseWallet?: true;
+            isDawn?: true;
+            isEnkrypt?: true;
+            isExodus?: true;
+            isFrame?: true;
+            isFrontier?: true;
+            isGamestop?: true;
+            isHyperPay?: true;
+            isImToken?: true;
+            isKuCoinWallet?: true;
+            isMathWallet?: true;
+            isMetaMask?: true;
+            isOkxWallet?: true;
+            isOKExWallet?: true;
+            isOneInchAndroidWallet?: true;
+            isOneInchIOSWallet?: true;
+            isOpera?: true;
+            isPhantom?: true;
+            isPortal?: true;
+            isRabby?: true;
+            isRainbow?: true;
+            isStatus?: true;
+            isTally?: true;
+            isTokenPocket?: true;
+            isTokenary?: true;
+            isTrust?: true;
+            isTrustWallet?: true;
+            isUniswapWallet?: true;
+            isXDEFI?: true;
+            isZerion?: true;
+            providers?: /*elided*/ any[];
+            _events?: {
+                connect?: (() => void) | undefined;
+            } | undefined;
+            _state?: {
+                accounts?: string[];
+                initialized?: boolean;
+                isConnected?: boolean;
+                isPermanentlyDisconnected?: boolean;
+                isUnlocked?: boolean;
+            } | undefined;
+        }[];
+        _events?: {
+            connect?: (() => void) | undefined;
+        } | undefined;
+        _state?: {
+            accounts?: string[];
+            initialized?: boolean;
+            isConnected?: boolean;
+            isPermanentlyDisconnected?: boolean;
+            isUnlocked?: boolean;
+        } | undefined;
+    }>;
+    getClient?: (parameters?: {
+        chainId?: number | undefined;
+    } | undefined) => Promise<import("viem").Client>;
+    isAuthorized: () => Promise<boolean>;
+    switchChain?: (parameters: import("@wagmi/core/internal").Compute<{
+        addEthereumChainParameter?: import("@wagmi/core/internal").ExactPartial<import("@wagmi/core/internal").Omit<import("viem").AddEthereumChainParameter, "chainId">> | undefined;
+        chainId: number;
+    }>) => Promise<Chain>;
+    onAccountsChanged: (accounts: string[]) => void;
+    onChainChanged: (chainId: string) => void;
+    onConnect: ((connectInfo: import("viem").ProviderConnectInfo) => void) & ((connectInfo: import("viem").ProviderConnectInfo) => void);
+    onDisconnect: (error?: Error | undefined) => void;
+    onMessage?: (message: import("viem").ProviderMessage) => void;
+};

package/dist/paraConnector.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-IV3L3JVM.js";
+import { injected } from "wagmi/connectors";
+import { ParaEIP1193Provider } from "./ParaEIP1193Provider.js";
+import { createConnector } from "wagmi";
+const PARA_ID = "para";
+const PARA_NAME = "Para";
+const PARA_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjE2IiBoZWlnaHQ9IjIwNCIgdmlld0JveD0iMCAwIDIxNiAyMDQiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik02MCAwSDE0NEMxODMuNzY0IDAgMjE2IDMyLjIzNTUgMjE2IDcyQzIxNiAxMTEuNzY1IDE4My43NjQgMTQ0IDE0NCAxNDRIOTZDODIuNzQ1MiAxNDQgNzIgMTU0Ljc0NSA3MiAxNjhWMjA0SDBWMTMySDM2QzQ5LjI1NDggMTMyIDYwIDEyMS4yNTUgNjAgMTA4TDYwIDBaIiBmaWxsPSJibGFjayIvPgo8L3N2Zz4K";
+const createParaConnector = ({
+  para,
+  chains: _chains,
+  disableModal,
+  storageOverride,
+  options,
+  iconOverride,
+  nameOverride,
+  idOverride,
+  transports,
+  renderModal
+}) => {
+  return createConnector((config) => {
+    const chains = [...config.chains];
+    const eip1193Provider = new ParaEIP1193Provider({
+      para,
+      chainId: `${chains[0].id}`,
+      chains,
+      disableModal,
+      storageOverride,
+      transports: transports || config.transports,
+      renderModal
+    });
+    const injectedObj = injected(__spreadValues({
+      target: {
+        name: PARA_NAME,
+        id: idOverride != null ? idOverride : PARA_ID,
+        provider: eip1193Provider
+      }
+    }, options))(config);
+    return __spreadProps(__spreadValues({}, injectedObj), {
+      type: idOverride != null ? idOverride : PARA_ID,
+      name: nameOverride != null ? nameOverride : PARA_NAME,
+      icon: iconOverride != null ? iconOverride : PARA_ICON,
+      disconnect: () => __async(void 0, null, function* () {
+        eip1193Provider.closeModal();
+        yield injectedObj.disconnect();
+      })
+    });
+  });
+};
+const paraConnector = (opts) => {
+  return createParaConnector(opts);
+};
+export {
+  createParaConnector,
+  paraConnector
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@getpara/wagmi-v2-connector",
-  "version": "2.0.0-alpha.60",
+  "version": "2.0.0-alpha.61",
   "dependencies": {
-    "@getpara/viem-v2-integration": "2.0.0-alpha.60",
-    "@getpara/web-sdk": "2.0.0-alpha.60"
+    "@getpara/viem-v2-integration": "2.0.0-alpha.61",
+    "@getpara/web-sdk": "2.0.0-alpha.61"
   },
   "devDependencies": {
     "typescript": "^5.8.3",
@@ -14,7 +14,7 @@
     "dist",
     "package.json"
   ],
-  "gitHead": "b445d9dcf909a9bfa72d4f21b825fcf7c643be0c",
+  "gitHead": "3a84954ff65c95d95fa96794bf0b0d4dc646c624",
   "main": "dist/index.js",
   "peerDependencies": {
     "react": "*",