@ant-design/web3-wagmi 0.0.0-alpha-20260209094036

package/dist/esm/wagmi-provider/__mocks__/wagmiBaseMock.d.ts

@@ -0,0 +1,76 @@
+export declare const wagmiBaseMock: {
+    useAccount: () => {
+        chain: {
+            blockExplorers: {
+                readonly default: {
+                    readonly name: "Etherscan";
+                    readonly url: "https://etherscan.io";
+                    readonly apiUrl: "https://api.etherscan.io/api";
+                };
+            };
+            blockTime?: number | undefined;
+            contracts: {
+                readonly ensRegistry: {
+                    readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+                };
+                readonly ensUniversalResolver: {
+                    readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+                    readonly blockCreated: 19258213;
+                };
+                readonly multicall3: {
+                    readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                    readonly blockCreated: 14353601;
+                };
+            };
+            ensTlds?: readonly string[] | undefined;
+            id: 1;
+            name: "Ethereum";
+            nativeCurrency: {
+                readonly name: "Ether";
+                readonly symbol: "ETH";
+                readonly decimals: 18;
+            };
+            experimental_preconfirmationTime?: number | undefined;
+            rpcUrls: {
+                readonly default: {
+                    readonly http: readonly ["https://eth.merkle.io"];
+                };
+            };
+            sourceId?: number | undefined;
+            testnet?: boolean | undefined;
+            custom?: Record<string, unknown> | undefined;
+            fees?: import("viem").ChainFees<undefined> | undefined;
+            formatters?: undefined;
+            serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable<bigint, number>> | undefined;
+        };
+        address: string;
+        connector: {
+            name: string;
+        };
+    };
+    useConfig: () => {};
+    useBalance: () => {
+        data: {};
+    };
+    useSwitchChain: () => {
+        switchChain: () => void;
+    };
+    useConnect: () => {
+        connectors: {
+            name: string;
+        }[];
+        connectAsync: () => Promise<{}>;
+    };
+    useDisconnect: () => {
+        disconnectAsync: () => void;
+    };
+    useEnsName: () => {
+        data: null;
+    };
+    useEnsAvatar: () => {
+        data: null;
+    };
+    useSignMessage: () => {
+        signMessageAsync: () => Promise<string>;
+    };
+};

package/dist/esm/wagmi-provider/__mocks__/wagmiBaseMock.js

@@ -0,0 +1,36 @@
+import { mainnet } from 'wagmi/chains';
+const mockConnector = {
+  name: 'MetaMask'
+};
+export const wagmiBaseMock = {
+  useAccount: () => {
+    return {
+      chain: mainnet,
+      address: '0x21CDf0974d53a6e96eF05d7B324a9803735fFd3B',
+      connector: mockConnector
+    };
+  },
+  useConfig: () => ({}),
+  useBalance: () => ({
+    data: {}
+  }),
+  useSwitchChain: () => ({
+    switchChain: () => {}
+  }),
+  useConnect: () => ({
+    connectors: [mockConnector],
+    connectAsync: async () => ({})
+  }),
+  useDisconnect: () => ({
+    disconnectAsync: () => {}
+  }),
+  useEnsName: () => ({
+    data: null
+  }),
+  useEnsAvatar: () => ({
+    data: null
+  }),
+  useSignMessage: () => ({
+    signMessageAsync: async () => 'signMessage'
+  })
+};

package/dist/esm/wagmi-provider/config-provider.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { type Chain, type Locale } from '@ant-design/web3-common';
+import type { Config as WagmiConfig } from 'wagmi';
+import type { EIP6963Config, SIWEConfig, WalletFactory } from '../interface';
+export interface AntDesignWeb3ConfigProviderProps {
+    chainAssets: Chain[];
+    walletFactories: WalletFactory[];
+    locale?: Locale;
+    children?: React.ReactNode;
+    ens?: boolean;
+    balance?: boolean;
+    eip6963?: EIP6963Config;
+    wagimConfig: WagmiConfig;
+    useWalletConnectOfficialModal?: boolean;
+    siwe?: SIWEConfig;
+    /**
+     * If true, this provider's configuration will be ignored when merging with parent context.
+     * This is useful when you have multiple chain providers and want to switch between them
+     * without causing page flickering. Only the active provider should not have this flag set.
+     */
+    ignoreConfig?: boolean;
+}
+export declare const AntDesignWeb3ConfigProvider: React.FC<AntDesignWeb3ConfigProviderProps>;

package/dist/esm/wagmi-provider/config-provider.js

@@ -0,0 +1,243 @@
+import React from 'react';
+import { ConnectStatus, Web3ConfigProvider } from '@ant-design/web3-common';
+import { useAccount, useBalance, useConfig, useConnect, useEnsAvatar, useEnsName, useSignMessage, useSwitchChain } from 'wagmi';
+import { disconnect, getAccount } from 'wagmi/actions';
+import { Mainnet } from "../chains";
+import { isEIP6963Connector } from "../utils";
+import { EIP6963Wallet } from "../wallets/eip6963";
+import { getNFTMetadata } from "./methods";
+import { jsx as _jsx } from "react/jsx-runtime";
+export const AntDesignWeb3ConfigProvider = props => {
+  const {
+    children,
+    chainAssets,
+    walletFactories,
+    ens = true,
+    balance,
+    locale,
+    eip6963,
+    wagimConfig,
+    useWalletConnectOfficialModal,
+    siwe,
+    ignoreConfig
+  } = props;
+  const {
+    address,
+    isDisconnected,
+    chain,
+    addresses
+  } = useAccount();
+  const config = useConfig();
+  const {
+    connectAsync
+  } = useConnect();
+  const {
+    switchChain
+  } = useSwitchChain();
+  const {
+    data: balanceData
+  } = useBalance({
+    address
+  });
+  const {
+    data: ensName
+  } = useEnsName({
+    address
+  });
+  const {
+    data: ensAvatar
+  } = useEnsAvatar({
+    name: ensName ?? undefined
+  });
+  const {
+    signMessageAsync
+  } = useSignMessage();
+  const [status, setStatus] = React.useState(ConnectStatus.Disconnected);
+  React.useEffect(() => {
+    setStatus(isDisconnected ? ConnectStatus.Disconnected : ConnectStatus.Connected);
+  }, [isDisconnected]);
+  const account = address && !isDisconnected ? {
+    address,
+    name: ensName && ens ? ensName : undefined,
+    avatar: ensAvatar ?? undefined,
+    addresses,
+    status: status
+  } : undefined;
+  const isConnectorNameMatch = (aName, bName) => {
+    // match connector name like okxWallet, Okx Wallet, OKX Wallet
+    return aName.replace(/ /g, '').toLowerCase() === bName.replace(/ /g, '').toLowerCase();
+  };
+  const findConnectorByName = name => {
+    const commonConnector = wagimConfig.connectors.find(item => isConnectorNameMatch(item.name, name) && !isEIP6963Connector(item));
+    if (!eip6963) {
+      return commonConnector;
+    }
+    const eip6963Connector = wagimConfig.connectors.find(item => item.name === name && isEIP6963Connector(item));
+    return eip6963Connector || commonConnector;
+  };
+  const wallets = React.useMemo(() => {
+    const autoAddEIP6963Wallets = [];
+    wagimConfig.connectors.forEach(connector => {
+      if (isEIP6963Connector(connector)) {
+        // check is need auto add eip6963 wallet
+        if (typeof eip6963 === 'object' && eip6963?.autoAddInjectedWallets && !walletFactories.find(item => item.connectors.some(aName => isConnectorNameMatch(aName, connector.name)))) {
+          // not config wallet and find the wallet in connectors, auto add it
+          autoAddEIP6963Wallets.push(EIP6963Wallet().create([connector], {
+            useWalletConnectOfficialModal
+          }));
+        }
+        // Do not need check eip6963 wallet
+        return;
+      }
+      const walletFactory = walletFactories.find(factory => factory.connectors.some(aName => isConnectorNameMatch(aName, connector.name)));
+      if (!walletFactory?.create) {
+        // check user wallets config and console.error for alert
+        console.error(`Can not find wallet factory for ${connector.name}, you should config it in WagmiWeb3ConfigProvider 'wallets'.`);
+      }
+    });
+
+    // Generate Wallet for @ant-design/web3
+    const supportWallets = walletFactories.map(factory => {
+      const connectors = factory.connectors.map(findConnectorByName).filter(item => !!item);
+      if (connectors.length === 0 && !eip6963) {
+        // Not config connector for this wallet factory and not use eip6963, ignore it.
+        console.error(`Can not find connector for ${factory.connectors.join(',')}, ignore the wallet. Please config connectors or add eip6963 config in WagmiWeb3ConfigProvider.`);
+        return null;
+      }
+      return factory.create(connectors, {
+        useWalletConnectOfficialModal
+      });
+    }).filter(item => item !== null);
+    return [...supportWallets, ...autoAddEIP6963Wallets];
+  }, [wagimConfig.connectors, walletFactories, eip6963]);
+  const chainList = React.useMemo(() => {
+    return wagimConfig.chains.map(item => {
+      const c = chainAssets?.find(asset => {
+        return asset.id === item.id;
+      });
+      if (c?.id) {
+        return {
+          id: c.id,
+          name: c.name,
+          icon: c.icon
+        };
+      }
+      console.error(`Can not find chain ${item.id}, you should config it in WagmiWeb3ConfigProvider 'chains'.`);
+      return null;
+    }).filter(item => item !== null);
+  }, [wagimConfig.chains, chainAssets]);
+  const chainId = chain?.id || wagimConfig.chains?.[0]?.id;
+  const chainName = chain?.name || wagimConfig.chains?.[0]?.name;
+  const [currentChain, setCurrentChain] = React.useState(undefined);
+  React.useEffect(() => {
+    setCurrentChain(prevChain => {
+      // not connected any chain, keep current chain
+      let newChain = chainAssets?.find(item => item?.id === chainId);
+      if (!newChain && chainId) {
+        newChain = {
+          id: chainId,
+          name: chainName
+        };
+      }
+
+      /* v8 ignore next */
+      return newChain || prevChain;
+    });
+  }, [chainAssets, wagimConfig.chains, chainId, chainName]);
+  const currency = currentChain?.nativeCurrency;
+  const getNFTMetadataFunc = React.useCallback(async ({
+    address: contractAddress,
+    tokenId
+  }) => getNFTMetadata(config, contractAddress, tokenId, chain?.id), [chain?.id]);
+  const signIn = React.useCallback(async signAddress => {
+    const {
+      getNonce,
+      createMessage,
+      verifyMessage
+    } = siwe;
+    let msg;
+    let signature;
+    try {
+      // get nonce
+      const nonce = await getNonce(signAddress);
+      msg = createMessage({
+        domain: window?.location ? window.location.hostname : '',
+        address: signAddress,
+        uri: window?.location ? window.location.origin : '',
+        nonce,
+        // Default config
+        version: '1',
+        chainId: currentChain?.id ?? Mainnet.id
+      });
+      if (signMessageAsync) {
+        signature = await signMessageAsync?.({
+          message: msg
+        });
+        await verifyMessage(msg, signature);
+        setStatus(ConnectStatus.Signed);
+      }
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }, [siwe, currentChain, signMessageAsync]);
+  return /*#__PURE__*/_jsx(Web3ConfigProvider, {
+    locale: locale,
+    availableChains: chainList,
+    chain: currentChain,
+    account: account,
+    sign: siwe && {
+      signIn
+    },
+    balance: balance ? {
+      symbol: balanceData?.symbol,
+      value: balanceData?.value,
+      decimals: balanceData?.decimals,
+      icon: currency?.icon
+    } : undefined,
+    availableWallets: wallets,
+    addressPrefix: "0x",
+    connect: async (wallet, options) => {
+      let connector = await wallet?.getWagmiConnector?.(options);
+      if (!connector && wallet) {
+        connector = findConnectorByName(wallet.name);
+      }
+      if (!connector) {
+        throw new Error(`Can not find connector for ${wallet?.name}`);
+      }
+      const {
+        accounts
+      } = await connectAsync({
+        connector,
+        chainId: currentChain?.id
+      });
+      return {
+        address: accounts?.[0],
+        addresses: accounts
+      };
+    },
+    disconnect: async () => {
+      // await disconnectAsync();
+      // TODO@jeasonstudio: wagmi useDisconnect hook 在处理多实例（config）共存时，
+      // 存在一些状态处理的 bug，暂时用更低阶 API 代替。
+      const {
+        connector
+      } = getAccount(config);
+      await disconnect(config, {
+        connector
+      });
+    },
+    switchChain: async newChain => {
+      if (!chain) {
+        // hava not connected any chain
+        setCurrentChain(newChain);
+      } else {
+        switchChain?.({
+          chainId: newChain.id
+        });
+      }
+    },
+    getNFTMetadata: getNFTMetadataFunc,
+    ignoreConfig: ignoreConfig,
+    children: children
+  });
+};

package/dist/esm/wagmi-provider/index.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { Locale } from '@ant-design/web3-common';
+import { QueryClient } from '@tanstack/react-query';
+import type { Transport } from 'viem';
+import type { Config, State } from 'wagmi';
+import type { WalletConnectParameters } from 'wagmi/connectors';
+import type { ChainAssetWithWagmiChain, EIP6963Config, SIWEConfig, WalletFactory } from '../interface';
+export interface WalletConnectOptions extends Pick<WalletConnectParameters, 'disableProviderPing' | 'isNewChainsStale' | 'projectId' | 'metadata' | 'relayUrl' | 'storageOptions' | 'qrModalOptions'> {
+    useWalletConnectOfficialModal?: boolean;
+}
+export interface WagmiWeb3ConfigProviderProps {
+    config?: Config;
+    locale?: Locale;
+    wallets?: WalletFactory[];
+    chains?: ChainAssetWithWagmiChain[];
+    ens?: boolean;
+    queryClient?: QueryClient;
+    balance?: boolean;
+    eip6963?: EIP6963Config;
+    initialState?: State;
+    reconnectOnMount?: boolean;
+    walletConnect?: false | WalletConnectOptions;
+    transports?: Record<number, Transport>;
+    siwe?: SIWEConfig;
+    /**
+     * If true, this provider's configuration will be ignored when merging with parent context.
+     * This is useful when you have multiple chain providers and want to switch between them
+     * without causing page flickering. Only the active provider should not have this flag set.
+     */
+    ignoreConfig?: boolean;
+}
+export declare function WagmiWeb3ConfigProvider({ children, config, locale, wallets, chains, ens, queryClient, balance, eip6963, walletConnect, transports, siwe, ignoreConfig, ...restProps }: React.PropsWithChildren<WagmiWeb3ConfigProviderProps>): React.ReactElement;

package/dist/esm/wagmi-provider/index.js

@@ -0,0 +1,102 @@
+import React from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { createConfig, http, WagmiProvider } from 'wagmi';
+import { mainnet } from 'wagmi/chains';
+import { walletConnect as wagmiWalletConnect } from 'wagmi/connectors';
+// Built in popular chains
+import { Mainnet } from "../chains";
+import { AntDesignWeb3ConfigProvider } from "./config-provider";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function WagmiWeb3ConfigProvider({
+  children,
+  config,
+  locale,
+  wallets = [],
+  chains = [],
+  ens,
+  queryClient,
+  balance,
+  eip6963,
+  walletConnect,
+  transports,
+  siwe,
+  ignoreConfig,
+  ...restProps
+}) {
+  // When user custom config, add Mainnet by default
+  // When user not provide config, auto generate config, chains use user provided chains
+  const chainAssets = config ? [Mainnet, ...chains] : chains?.length ? chains : [Mainnet];
+  const generateConfigFlag = () => {
+    return `${JSON.stringify(walletConnect)}-${chains.map(item => item.id).join(',')}-${wallets.map(item => item.name).join(',')}`;
+  };
+  const generateConfig = () => {
+    // Auto generate config
+    const connectors = [];
+    // biome-ignore lint/complexity/useOptionalChain: <explanation>
+    if (walletConnect && walletConnect.projectId) {
+      connectors.push(wagmiWalletConnect({
+        ...walletConnect,
+        showQrModal: walletConnect.useWalletConnectOfficialModal ?? false
+      }));
+    }
+    wallets.forEach(wallet => {
+      const connector = wallet.createWagmiConnector?.();
+      if (connector) {
+        connectors.push(connector);
+      }
+    });
+    const autoGenerateConfig = createConfig({
+      chains: chainAssets.map(chain => chain.wagmiChain),
+      transports: transports ?? {
+        [mainnet.id]: http()
+      },
+      connectors
+    });
+    return {
+      flag: generateConfigFlag(),
+      config: autoGenerateConfig
+    };
+  };
+  const [autoConfig, setAutoConfig] = React.useState(() => {
+    if (config) {
+      return {
+        config
+      };
+    }
+    return generateConfig();
+  });
+  const mergedQueryClient = React.useMemo(() => {
+    return queryClient ?? new QueryClient();
+  }, [queryClient]);
+  React.useEffect(() => {
+    if (config) {
+      return;
+    }
+    const flag = generateConfigFlag();
+    if (flag !== autoConfig.flag) {
+      // Need recreate wagmi config
+      setAutoConfig(generateConfig());
+    }
+  }, [config, wallets, chains, walletConnect]);
+  const wagmiConfig = config || autoConfig.config;
+  return /*#__PURE__*/_jsx(WagmiProvider, {
+    config: wagmiConfig,
+    ...restProps,
+    children: /*#__PURE__*/_jsx(QueryClientProvider, {
+      client: mergedQueryClient,
+      children: /*#__PURE__*/_jsx(AntDesignWeb3ConfigProvider, {
+        locale: locale,
+        siwe: siwe,
+        chainAssets: chainAssets,
+        walletFactories: wallets,
+        ens: ens,
+        balance: balance,
+        eip6963: eip6963,
+        wagimConfig: wagmiConfig,
+        useWalletConnectOfficialModal: typeof walletConnect === 'object' && walletConnect?.useWalletConnectOfficialModal,
+        ignoreConfig: ignoreConfig,
+        children: children
+      })
+    })
+  });
+}

package/dist/esm/wagmi-provider/methods/getNFTMetadata.d.ts

@@ -0,0 +1,3 @@
+import { type NFTMetadata } from '@ant-design/web3-common';
+import type { Config } from 'wagmi';
+export declare function getNFTMetadata(config: Config, address: string, tokenId: bigint, chainId?: number): Promise<NFTMetadata>;

package/dist/esm/wagmi-provider/methods/getNFTMetadata.js

@@ -0,0 +1,25 @@
+import { fillAddressWith0x, requestWeb3Asset } from '@ant-design/web3-common';
+import { readContract } from 'wagmi/actions';
+export async function getNFTMetadata(config, address, tokenId, chainId) {
+  const tokenURI = await readContract(config, {
+    address: fillAddressWith0x(address),
+    args: [tokenId],
+    chainId,
+    abi: [{
+      name: 'tokenURI',
+      inputs: [{
+        name: 'tokenId',
+        type: 'uint256'
+      }],
+      outputs: [{
+        name: '',
+        type: 'string'
+      }],
+      stateMutability: 'view',
+      type: 'function'
+    }],
+    functionName: 'tokenURI'
+  });
+  const metaInfo = await requestWeb3Asset(tokenURI);
+  return metaInfo;
+}

package/dist/esm/wagmi-provider/methods/index.d.ts

@@ -0,0 +1 @@
+export * from './getNFTMetadata';

package/dist/esm/wagmi-provider/methods/index.js

@@ -0,0 +1 @@
+export * from "./getNFTMetadata";

package/dist/esm/wallets/coinbase-wallet.d.ts

@@ -0,0 +1,4 @@
+import type { WalletMetadata } from '@ant-design/web3-common';
+import { type CoinbaseWalletParameters } from 'wagmi/connectors';
+import type { WalletFactory } from '../interface';
+export declare const CoinbaseWallet: (metadata?: Partial<WalletMetadata>, coinbaseConfig?: CoinbaseWalletParameters) => WalletFactory;

package/dist/esm/wallets/coinbase-wallet.js

@@ -0,0 +1,19 @@
+import { metadata_CoinbaseWallet } from '@ant-design/web3-assets';
+import { coinbaseWallet } from 'wagmi/connectors';
+export const CoinbaseWallet = (metadata, coinbaseConfig) => {
+  return {
+    connectors: ['Coinbase Wallet'],
+    create: () => {
+      return {
+        ...metadata_CoinbaseWallet,
+        hasWalletReady: async () => {
+          return true;
+        },
+        ...metadata
+      };
+    },
+    createWagmiConnector: () => {
+      return coinbaseWallet(coinbaseConfig);
+    }
+  };
+};

package/dist/esm/wallets/eip6963.d.ts

@@ -0,0 +1,3 @@
+import type { EthereumWallet } from '../interface';
+export declare const EIP6963_CONNECTOR = "EIP6963";
+export declare const EIP6963Wallet: EthereumWallet;

package/dist/esm/wallets/eip6963.js

@@ -0,0 +1,27 @@
+export const EIP6963_CONNECTOR = 'EIP6963';
+
+// EIP6963Wallet not export from @ant-design/web3-wagmi, only used in internal
+export const EIP6963Wallet = metadata => {
+  return {
+    connectors: [EIP6963_CONNECTOR],
+    create: connectors => {
+      const connector = connectors?.[0];
+      const metadata_eip6963 = {
+        icon: connector?.icon,
+        name: connector.name,
+        remark: `Wallet ${connector?.name} detected`,
+        key: connector?.id
+      };
+      return {
+        ...metadata_eip6963,
+        hasWalletReady: async () => {
+          return !!(await connector?.getProvider());
+        },
+        hasExtensionInstalled: async () => {
+          return !!(await connector?.getProvider());
+        },
+        ...metadata
+      };
+    }
+  };
+};

package/dist/esm/wallets/im-token.d.ts

@@ -0,0 +1,2 @@
+import type { EthereumWallet } from '../interface';
+export declare const ImToken: EthereumWallet;

package/dist/esm/wallets/im-token.js

@@ -0,0 +1,11 @@
+import { metadata_imToken } from '@ant-design/web3-assets';
+import { injected } from 'wagmi/connectors';
+import { UniversalWallet } from "./universal-wallet";
+export const ImToken = metadata => {
+  return new UniversalWallet({
+    ...metadata_imToken,
+    ...metadata
+  }, () => injected({
+    target: 'imToken'
+  }));
+};

package/dist/esm/wallets/index.d.ts

@@ -0,0 +1,10 @@
+export * from './meta-mask';
+export * from './wallet-connect';
+export * from './coinbase-wallet';
+export * from './token-pocket';
+export * from './safeheron';
+export * from './universal-wallet';
+export * from './okx-wallet';
+export * from './im-token';
+export * from './mobile-wallet';
+export * from './rainbow-wallet';

package/dist/esm/wallets/index.js

@@ -0,0 +1,10 @@
+export * from "./meta-mask";
+export * from "./wallet-connect";
+export * from "./coinbase-wallet";
+export * from "./token-pocket";
+export * from "./safeheron";
+export * from "./universal-wallet";
+export * from "./okx-wallet";
+export * from "./im-token";
+export * from "./mobile-wallet";
+export * from "./rainbow-wallet";

package/dist/esm/wallets/meta-mask.d.ts

@@ -0,0 +1,2 @@
+import type { EthereumWallet } from '../interface';
+export declare const MetaMask: EthereumWallet;

package/dist/esm/wallets/meta-mask.js

@@ -0,0 +1,11 @@
+import { metadata_MetaMask } from '@ant-design/web3-assets';
+import { injected } from 'wagmi/connectors';
+import { UniversalWallet } from "./universal-wallet";
+export const MetaMask = metadata => {
+  return new UniversalWallet({
+    ...metadata_MetaMask,
+    ...metadata
+  }, () => injected({
+    target: 'metaMask'
+  }));
+};

package/dist/esm/wallets/mobile-wallet.d.ts

@@ -0,0 +1,2 @@
+import { type EthereumWalletConnect } from './wallet-connect';
+export declare const MobileWallet: EthereumWalletConnect;

package/dist/esm/wallets/mobile-wallet.js

@@ -0,0 +1,8 @@
+import { metadata_MobileConnect } from '@ant-design/web3-assets';
+import { WalletConnect } from "./wallet-connect";
+export const MobileWallet = metadata => {
+  return WalletConnect({
+    ...metadata_MobileConnect,
+    ...metadata
+  });
+};