代码

walletConn.js-连接钱包使用到的方法:

import AuthClient, { generateNonce } from "@walletconnect/auth-client";

import { Web3Modal } from "@web3modal/standalone";
import UniversalProvider from "@walletconnect/universal-provider";
import { ethers, providers as wc_providers, utils } from 'ethers'
import { tips, msg } from "./common";
import { ERC20_ADDRESS, DEFAULT_CHAIN_DATA, DEFAULT_CHAINS, DEFAULT_PROJECT_ID, DEFAULT_RELAY_URL, DEFAULT_LOGGER } from "./constants"
import store from "/src/store";
import { watch, ref, shallowRef } from "vue"
import { formatTestTransaction } from "./tx"
import ERC20Abi from "../core/abi/ERC20.json"

// let ethereumProvider, 
//   web3Provider, 
//   pairings,
//   session,
//   caipChainId,
//   chainData,
//   client,
//   accounts,
//   balances,
//   isFetchingBalances,
//   isInitializing,
//   web3Modal, 
//   wc_client, 
//   wc_address, 
//   wc_uri;
let client = ref(),
    pairings=ref([]),
    session=ref(),
    ethereumProvider=ref(),
    web3Provider=shallowRef(),
    isFetchingBalances=ref(false),
    isInitializing=ref(false),
    hasCheckedPersistedSession=ref(false),
    balances=ref({}),
    accounts=ref([]),
    chainData=ref({}),
    chain=ref(''),
    web3Modal=ref(),
    contract=ref();
const setClient = (v) => {
    client.value = v
    store.commit('SetAuthClient', v)
}
const setPairings = (v) => {
    pairings.value = v
}
const setSession = (v) => {
    session.value = v
}
const setEthereumProvider = (v) => {
    ethereumProvider.value = v
}
const setWeb3Provider = (v) => {
    web3Provider.value = v
}
const setIsFetchingBalances = (v) => {
    isFetchingBalances.value = v
}
const setIsInitializing = (v) => {
    isInitializing.value = v
}
const setHasCheckedPersistedSession = (v) => {
    hasCheckedPersistedSession.value = v
}
const setBalances = (v) => {
    balances.value = v
}
const setAccounts = (v) => {
    accounts.value = v
    store.commit('SetAccountAddress', accounts.value?.[0] || '')
}
const setChainData = (v) => {
    chainData.value = v
}
const setChain = (v) => {
    chain.value = v
}
const setWeb3Modal = (v) => {
    web3Modal.value = v
}
const testSendTransaction = async () => {
    if (!web3Provider.value) {
      throw new Error("web3Provider not connected");
    }

    let { chainId } = await web3Provider.value.getNetwork();
    let [address] = await web3Provider.value.listAccounts();
    let balance = await web3Provider.value.getBalance(address);

    let tx = await formatTestTransaction("eip155:" + chainId + ":" + address);

    if (balance.lt(BigNumber.from(tx.gasPrice).mul(tx.gasLimit))) {
      return {
        method: "eth_sendTransaction",
        address,
        valid: false,
        result: "Insufficient funds for intrinsic transaction cost",
      };
    }

    let txHash = await web3Provider.value.send("eth_sendTransaction", [tx]);

    return {
      method: "eth_sendTransaction",
      address,
      valid: true,
      result: txHash,
    };
};
const testSignTransaction = async () => {
    // if (!web3Provider.value) {
    //   throw new Error("web3Provider not connected");
    // }

    // let { chainId } = await web3Provider.value.getNetwork();
    // let [address] = await web3Provider.value.listAccounts();

    // let tx = await formatTestTransaction("eip155:" + chainId + ":" + address);
    // let signedTx = await web3Provider.value.send("eth_signTransaction", [tx]);
    // let valid = Transaction.fromSerializedTx(signedTx ).verifySignature();

    // return {
    //   method: "eth_signTransaction",
    //   address,
    //   valid,
    //   result: signedTx,
    // };
};
const getEthereumActions = () => {
    const wrapRpcRequest = async () => {
      openRequestModal();
      try {
        setIsRpcRequestPending(true);
        const result = await rpcRequest();
        setRpcResult(result);
      } catch (error) {
        console.error("RPC request failed:", error);
        setRpcResult(null);
      } finally {
        setIsRpcRequestPending(false);
      }
    };

    return [
      { method: "eth_sendTransaction", callback: wrapRpcRequest(testSendTransaction) },
      { method: "eth_signTransaction", callback: wrapRpcRequest(testSignTransaction) },
      { method: "personal_sign", callback: wrapRpcRequest(testSignMessage) },
      { method: "eth_sign (standard)", callback: wrapRpcRequest(testEthSign) },
      { method: "eth_signTypedData", callback: wrapRpcRequest(testSignTypedData) },
    ];
};
const getBlockchainActions = (_namespace='eip155') => {
    switch (_namespace) {
        case "eip155":
          return getEthereumActions();
        case "cosmos":
          return [];
        default:
          break;
    }
}


const getAllChainNamespaces = () => {
    let namespaces = []
    DEFAULT_CHAINS.forEach(chainId => {
        const [namespace] = chainId.split(":");
        if (!namespaces.includes(namespace)) {
            namespaces.push(namespace);
        }
    });
    return namespaces;
};

const resetApp = () => {
    setPairings([]);
    setSession(undefined);
    setBalances({});
    setAccounts([]);
    setChain("");
};
// const loadChainData = async () => {
//     let namespaces = getAllChainNamespaces();
//     console.log("loadChainData-namespaces=", namespaces)
//     let _chainData = {};
//     await Promise.all(
//         namespaces.map(async namespace => {
//         let chains;
//         try {
//             chains = await apiGetChainNamespace(namespace);
//         } catch (e) {
//             // ignore error
//             console.log("loadChainData-err=", e)
//         }
//         console.log("loadChainData-chains=", chains)
//         if (typeof chains !== "undefined") {
//             _chainData[namespace] = chains;
//         }
//         }),
//     );
//     setChainData(_chainData);
//     console.log("loadChainData-chainData=", chainData, _chainData)
// };
const loadChainData = async () => {
    let _chainData = DEFAULT_CHAIN_DATA
    setChainData(_chainData);
    // console.log("loadChainData-chainData=", chainData.value, _chainData)
};
const createClient = async () => {
    try {
        setIsInitializing(true);
        if (!DEFAULT_PROJECT_ID) return
        let provider = await UniversalProvider.init({
            projectId: DEFAULT_PROJECT_ID,
            logger: DEFAULT_LOGGER,
            relayUrl: DEFAULT_RELAY_URL,
        });
        let _web3Modal = new Web3Modal({
            projectId: DEFAULT_PROJECT_ID,
            walletConnectVersion: 2,
        });
        setEthereumProvider(provider);
        setClient(provider.client);
        setWeb3Modal(_web3Modal);
    } catch (error) {
        throw error
    } finally {
        setIsInitializing(false);
    }
}
const createWeb3Provider = () => {
    if (ethereumProvider.value) {
        let _web3Provider = new wc_providers.Web3Provider(ethereumProvider.value);
        setWeb3Provider(_web3Provider);
        contract.value = new ethers.Contract(ERC20_ADDRESS, ERC20Abi.abi, _web3Provider);
    }
}
const onSessionConnected = async (_session) => {
    if (!ethereumProvider.value) {
        throw new ReferenceError("EthereumProvider is not initialized.");
    }
    let allNamespaceAccounts = Object.values(_session.namespaces)
    .map(namespace => namespace.accounts)
    .flat();
    let allNamespaceChains = Object.keys(_session.namespaces);
    let chainData = allNamespaceAccounts[0].split(":");

    let _caipChainId = `${chainData[0]}:${chainData[1]}`;
    // console.log("restored caipChainId", caipChainId);
    setChain(_caipChainId)
    setSession(_session);
    let _accounts = allNamespaceAccounts.map(account => account.split(":")[2])
    setAccounts(_accounts)
    // console.log("RESTORED", allNamespaceChains, allNamespaceAccounts);
    createWeb3Provider()
}
const _checkForPersistedSession = async () => {
    if (typeof ethereumProvider.value === "undefined") {
        throw new Error("WalletConnect is not initialized");
    }
    let _pairings = ethereumProvider.value.client.pairing.getAll({ active: true });
    setPairings(_pairings)
    // console.log("RESTORED PAIRINGS: ", _pairings);
    if (typeof session !== "undefined") return;
    // populates (the last) existing session to state
    if (ethereumProvider.value?.session) {
        let _session = ethereumProvider.value?.session;
        // console.log("RESTORED SESSION:", _session);
        await onSessionConnected(_session);
        return _session;
    }
}
const _subscribeToProviderEvents = () => {
    let _client = ethereumProvider.value
    if (typeof _client === "undefined") {
        throw new Error("WalletConnect is not initialized-2");
    }
    _client.on("display_uri", async (uri) => {
        // console.log("EVENT", "QR Code Modal open", uri);
        web3Modal.value?.openModal({ uri });
    });

    // Subscribe to session ping
    _client.on("session_ping", ({ id, topic }) => {
        console.log("_subscribeToProviderEvents-EVENT", "session_ping",id, topic);
        // console.log(id, topic);
    });

    // Subscribe to session event
    _client.on("session_event", ({ event, chainId }) => {
        console.log("_subscribeToProviderEvents-EVENT", "session_event",event, chainId);
        // console.log(event, chainId);
    });
    // Subscribe to session update
    _client.on("session_update",({ topic, session }) => {
        console.log("_subscribeToProviderEvents-EVENT", "session_updated", session);
        setSession(session);
    });
    // Subscribe to session delete
    _client.on("session_delete", ({ id, topic }) => {
        console.log("_subscribeToProviderEvents-EVENT", "session_deleted",id, topic);
        // console.log(id, topic);
        resetApp();
        location.reload()
    });
}
const disconnect = async () => {
    if (typeof ethereumProvider.value === "undefined") {
        throw new Error("ethereumProvider is not initialized");
    }
    await ethereumProvider.value.disconnect();
    resetApp();
}
const connect = async (caipChainId) => {
    if (!ethereumProvider.value) {
        // throw new ReferenceError("WalletConnect Client is not initialized.");
        throw ("WalletConnect Client is not initialized.")
    }
    let chainId = caipChainId?.split(":")?.pop();
    // console.log("Enabling EthereumProvider for chainId: ", chainId, ethereumProvider.value);
    let _session = await ethereumProvider.value.connect({
        namespaces: {
        eip155: {
            methods: [
            "eth_sendTransaction",
            "eth_signTransaction",
            "eth_sign",
            "personal_sign",
            "eth_signTypedData",
            ],
            chains: [`eip155:${chainId}`],
            events: ["chainChanged", "accountsChanged"],
            rpcMap: {chainId: `https://rpc.walletconnect.com?chainId=eip155:${chainId}&projectId=${DEFAULT_PROJECT_ID}`,},
        },
        },
        pairingTopic: pairings.value?.topic,
    });
    createWeb3Provider()
    let _accounts = await ethereumProvider.value.enable();
    // console.log("_accounts", _accounts);
    setAccounts(_accounts);
    setSession(_session);
    setChain(caipChainId);
    web3Modal.value?.closeModal();
    let res = {
        contract: contract.value,
        provider: web3Provider.value,
    }
    console.log("connect-res=", res)
    return res
}

const fetchBalances = async () => {
    if (!web3Provider.value || !accounts.value || (accounts.value && accounts.value.length<1)) return;
    // console.log("fetchBalances-accounts=", accounts.value)
    // let _balance = await web3Provider.value.getBalance('0xdcc8Da7Dea909C8CA4948d00774a453C169aB7c5');
    // console.log("fetchBalances-_balance", _balance)
    try {
        // console.log("fetchBalances-try1")
        setIsFetchingBalances(true);
        // console.log("fetchBalances-try2")
        let _balances = await Promise.all(
            accounts.value.map(async account => {
                console.log("balance1=", account, web3Provider.value)
                let balance = await web3Provider.value.getBalance(account);
                console.log("balance2=", balance)
                return {
                    account,
                    symbol: "ETH",
                    balance: utils.formatEther(balance),
                    contractAddress: "",
                };
            }),
        );
        // console.log("fetchBalances_balances=", _balances)
        let balancesByAccount = _balances.reduce((obj, balance) => {
            obj[balance.account] = balance;
            return obj;
        }, {});
        // console.log("fetchBalances-balancesByAccount=", balancesByAccount)
        setBalances(balancesByAccount);

    } catch (error) {
        // throw new Error(error);
        console.log("fetchBalances-error=", error)
    } finally {
        setIsFetchingBalances(false);
    }
}
const getPersistedSession = async () => {
    if (!ethereumProvider.value) return;
    await _checkForPersistedSession();
    setHasCheckedPersistedSession(true);
}
const initWalletConn = () => {
    loadChainData()
    wc_watch()
}

const wc_watch = () => {
    // console.log("开始wc_watch")
    watch(client, (e) => {
        // console.log("开始wc_watch-client", e)
        if (!e) {
            createClient()
        }
    }, {immediate: true})
    watch([ethereumProvider, web3Modal], ([newA, newB], [oldA, oldB]) => {
        // console.log("开始wc_watch-ethereumProvider, web3Modal")
        if (newA && newB) _subscribeToProviderEvents()
    }, {immediate: true})
    // watch([web3Provider, accounts], ([newA, newB], [oldA, oldB]) => {
    //     // console.log("开始wc_watch-web3Provider, accounts")
    //     fetchBalances()
    // }, {immediate: true})
    watch([ethereumProvider, chainData, hasCheckedPersistedSession], ([newA, newB, newC], [oldA, oldB, oldC]) => {
        // console.log("开始wc_watch-ethereumProvider, chainData, hasCheckedPersistedSession")
        if (newA && newB && !newC) {
            getPersistedSession();
        }
    }, {immediate: true})
}

export {
    pairings,
    isInitializing,
    balances,
    isFetchingBalances,
    accounts,
    chain,
    client,
    session,
    disconnect,
    connect,
    chainData,
    web3Provider,
    loadChainData,
    initWalletConn,
    wc_watch
}

chainWallet.js-连接钱包使用到的方法：

import store from "@/store"
import { NETWORK_METADATA, getChainName, isSupportedChain, getChainId } from "./chain"
import { ethers } from "ethers";
import { Notification } from 'element-ui';

export function formatUnits(balance) {
  return ethers.utils.formatUnits(balance, TOKEN_DECIMAL)
}

export function parseUnits(balance) {
  return ethers.utils.parseUnits(balance, TOKEN_DECIMAL)
}

export function isAddress(address) {
  return ethers.utils.isAddress(address)
}
// MetaMask TrustWallet TokenPocket     CoinbaseWallet    WalletConnect
export async function initDigitalType(providerName = '') {
  return new Promise(async (resolve, reject) => {
    if (!providerName) {
      return reject()
    }
    const { ethereum } = window;
    
    if (providerName === 'WalletConnect') {
      // initWalletConnect().then((res) => {
      //   contract = res.contract
      //   provider = res.provider
      // })
      // return resolve({ contract, provider })
      console.log("initWalletConnectB-providerName=", providerName)
      connect(DEFAULT_CHAIN)
      return resolve({ contract, provider })
    }
    if (!ethereum) {
      msg('您还没有安装钱包')
      return reject()
    }
    if (providerName === 'MetaMask' && !hasMetaMaskWalletExtension()) {
      tips('MetaMask not detected \n Install MetaMask').then(res => {
        window.open('https://metamask.io')
      })
      return reject()
    }
    if (providerName === 'TrustWallet' && !hasTrustWalletExtension()) {
      tips('TrustWallet not detected \n Install TrustWallet').then(res => {
        window.open('https://trustwallet.com')
      })
      return reject()
    }
    if (providerName === 'CoinbaseWallet' && !hasCoinBaseWalletExtension()) {
      tips('CoinbaseWallet not detected \n Install CoinbaseWallet').then(res => {
        window.open('https://www.coinbase.com')
      })
      return reject()
    }
    if (providerName === 'TokenPocket' && !hasTokenPocketWalletExtension()) {
      tips('TokenPocket not detected \n Install TokenPocket').then(res => {
        window.open('https://www.tokenpocket.pro')
      })
      return reject()
    }
    if (providerName === 'imToken' && !hasImTokenExtension()) {
      tips('imToken not detected \n Install imToken').then(res => {
        // window.open('https://www.tokenpocket.pro')
      })
      return reject()
    }
    store.commit('SetProviderName', providerName)
  })
}
export function activateSafePal() {

}
export function activateMetaMask() {
    console.log("activateMetaMask")
    if (!hasMetaMaskWalletExtension()) {
        alert("MetaMask not detected.")
        return
    }
    attemptActivateWallet("MetaMask");
}

export function hasMetaMaskWalletExtension() {
    const { ethereum } = window;
    if (!ethereum.hasOwnProperty('providers') && !ethereum.hasOwnProperty('isMetaMask')) {
        return false;
    }

    return window.ethereum.isMetaMask || ethereum.providers.find(({ isMetaMask }) => isMetaMask);
}
export function hasTrustWalletExtension() {
  const { ethereum } = window;
  if (!ethereum?.providers && !ethereum?.isTrust) {
    return false;
  }
  return ethereum?.isTrust;
}
export function hasCoinBaseWalletExtension() {
  const { ethereum } = window;
  if (!ethereum?.providers && !ethereum?.isCoinbaseWallet) {
    return false;
  }
  return ethereum.isCoinbaseWallet || ethereum.providers.find(({ isCoinbaseWallet }) => isCoinbaseWallet);
}

export function hasTokenPocketWalletExtension() {
  const { ethereum } = window;
  if (!ethereum?.providers && !ethereum?.isTokenPocket) {
    return false;
  }
  return ethereum.isTokenPocket;
}

export function hasImTokenExtension() {
  const { ethereum } = window;
  if (!ethereum?.providers && !ethereum?.isImToken) {
    return false;
  }
  return ethereum.isImToken;
}
export function getProvider() {
    let { ethereum } = window;
    let web3Provider = new ethers.providers.Web3Provider(ethereum);
    // console.log("web3Provider=", web3Provider)
    return web3Provider
}
function attemptActivateWallet(providerName) {
    activateInjectedProvider(providerName);
    connectInjectedWallet(providerName);
};
function activateInjectedProvider(providerName) {
    const { ethereum } = window;
    if (!ethereum.hasOwnProperty('providers') && !ethereum.hasOwnProperty('isCoinbaseWallet') && !ethereum.hasOwnProperty('isMetaMask')
        && !ethereum.hasOwnProperty('isSafePal') && !ethereum.hasOwnProperty('isTrust')
    ) {
        return undefined;
    }

    let provider;
    if (ethereum.hasOwnProperty('providers')) {
        switch (providerName) {
            case "CoinBase":
                provider = ethereum.providers.find(({ isCoinbaseWallet }) => isCoinbaseWallet);
                break;
            case "Trust":
                provider = ethereum.providers.find(({ isTrust }) => isTrust);
            case "TokenPocket":
                provider = ethereum.providers.find(({ isTokenPocket }) => isTokenPocket);
            case "imToken":
                provider = ethereum.providers.find(({ isImToken }) => isImToken);
            case "Safepal":
                provider = ethereum.providers.find(({ isSafePal }) => isSafePal);
            case "MetaMask":
            default:
                provider = ethereum.providers.find(({ isMetaMask }) => isMetaMask);
                break;
        }
    }

    if (provider) {
        ethereum.setSelectedProvider(provider);
    }
}
export async function setChainId() {
    let provider = getProvider()
    let network = await provider.getNetwork()
    let chainId = network.chainId
    if (!(chainId && isSupportedChain(chainId))) {
        chainId = ''
        store.commit('set_userAddress', '')
    }
    store.commit('set_chainId', chainId)
    switchOrAddNetwork()
}
async function connectInjectedWallet(providerName) {
    console.log("connectInjectedWallet==", providerName)
    let provider = getProvider()
    try {
        await provider.send("eth_requestAccounts", []);
        let signer = provider.getSigner();
        let userAddress = await signer.getAddress();
        console.log("userAddress==", userAddress)
        if (userAddress) {
            // store.commit('set_chainWallet', { type: 1, key: 'address', v: userAddress })
            store.commit('set_userAddress', userAddress)
            let network = await provider.getNetwork()
            let chainIdTrue = network.chainId
            if (!isSupportedChain(chainIdTrue)) {
                checkNetChainId()
            } else {
                setChainId()
            }
        }
    } catch (error) {
        console.log("connectInjectedWallet-error=", error)
        return
    }

}
export async function checkNetChainId() {
    let provider = getProvider()
    let network = await provider.getNetwork()
    let chainId = network.chainId
    if (chainId && !isSupportedChain(chainId)) {
        switchOrAddNetwork()
    }
    if (chainId && isSupportedChain(chainId)) {
        // store.commit('set_chainWallet', { type: 1, key: 'chainId', v: chainId })
        store.commit('set_chainId', chainId)
    }
}
export async function switchAndAddNetChain(chainId, network_name) {
    let { ethereum } = window
    let chainId_16 = "0x" + Math.abs(chainId).toString(16);
    try {
        await ethereum.request({
            method: 'wallet_switchEthereumChain',
            params: [
                { chainId: chainId_16 }
            ],
        })
        // store.commit('set_chainWallet', { type: 1, key: 'chainId', v: chainId })
        //   tipOneLine("wallet.connectSuccess", {name: network_name})

        Notification({
            title: `连接${network_name}成功`
        })

    } catch (switchError) {
        console.log("switchError=", switchError, chainId)
        if (switchError.code === 4902) {
            ethereum.request({
                method: 'wallet_addEthereumChain',
                params: [
                    {
                        chainId: chainId_16,
                        chainName: NETWORK_METADATA[chainId]['chainName'],
                        rpcUrls: NETWORK_METADATA[chainId]['rpcUrls'],
                        blockExplorerUrls: NETWORK_METADATA[chainId]['blockExplorerUrls'],
                        nativeCurrency: NETWORK_METADATA[chainId]['nativeCurrency']
                    }
                ],
            }).then(async r => {
                store.commit('set_chainId', chainId)
                // tipOneLine("wallet.connectSuccess", { name: network_name })
                Notification({
                    title: `连接${network_name}成功`
                })
                store.commit('set_connectWalletBox', false)
            }).catch(err => {
            })
        }
    }
}
export async function switchOrAddNetwork() {
    let chainIdTrue = getChainId()
    let chainId = store.state.chainId
    let address = store.state.address
    console.log("switchOrAddNetwork")
    console.log("switchOrAddNetwork-1", address, chainId)
    // if (!connectWalletState && !address) {
    //     return
    // }
    if (!address) {
        return
    }
    if (isSupportedChain(chainId)) {
        return
    }
    if (isSupportedChain(chainId) && address) {
        store.commit('set_active')
    }
    try {
        console.log("switchOrAddNetwork2")
        if (!isSupportedChain(chainId)) {
            // throw new Error(`Unsupported chainId ${chainId}`);
            throw (`Unsupported chainId ${chainId}`);
        }
    } catch (error) {
        console.log("switchOrAddNetwork3")
        let network_name = getChainName(chainIdTrue)
        Notification({
            title: `你的钱包没有连接到 ${network_name} `,
            dangerouslyUseHTMLString: true,
            // duration: 2,
            message: '<a href="javascript:void(0)" class="text-decoration">' + `切换到  ${network_name}` + '</a><br/>'
                + '<a href="javascript:void(0)" class="text-decoration">' + `添加到 ${network_name}` + '</a>',
            onClick(event) {
                // console.log('9999999999999999999', event.target)
                switchAndAddNetChain(chainIdTrue, network_name)
            },
            position: 'bottom-right',
            duration: '3000'
        });
    }

}
export const isNeedConnectWalletFun = () => {
    let active = store.state.active
    let chainId = store.state.chainId
    let address = store.state.address
    let res = false
    if (!active || !isSupportedChain(chainId) || !address) {
        res = true
    }
    return res
}
export function useInactiveListener() {
    let { ethereum } = window;
    let active = store.state.active
    let chainId = store.state.chainId

    if (ethereum && ethereum.on) {

        const handleConnect = () => {
            // console.log("handleConnect")
        };
        const handleDisconnect = (error) => {
            console.log("handleDisconnect=", error)
            store.commit('set_active')
        }
        const handleChainChanged = (chainId) => {
            console.log("handleChainChanged", chainId)
            setChainId()
        };
        const handleAccountsChanged = (accounts) => {
            if (accounts.length > 0) {
                store.commit('set_userAddress', accounts[0])
            } else {
                store.commit('set_userAddress', '')
            }
            console.log("handleAccountsChanged=", accounts)
        };
        if (ethereum?.removeListener) {
            ethereum.removeListener("connect", handleConnect);
            ethereum.removeListener("disconnect", handleDisconnect);
            ethereum.removeListener("chainChanged", handleChainChanged);
            ethereum.removeListener("accountsChanged", handleAccountsChanged);
        }
        ethereum.on("connect", handleConnect);
        ethereum.on('disconnect', handleDisconnect);
        ethereum.on("chainChanged", handleChainChanged);
        ethereum.on("accountsChanged", handleAccountsChanged);
    }
    if (ethereum && ethereum.on && active && isSupportedChain(chainId)) {
    }
}

chainEvent.js-事件：

// 这里是 链上合约的 事件相关 监听和调用
import { ethers } from "ethers";
import store from "@/store"
import { pool_contract_address } from "@/abis/address"
import Pools from "@/abis/Pools"
import exchangeRef from "./exchangeRef"
import { RPC_PROVIDERS } from "./chain"


export const getWsProvider = () => {
    let active = store.state.active
    let chainId = store.state.chainId
    if (!active) {
        return;
    }
    if (chainId) {
        // console.log("chainId==", chainId)
        const opWsProvider = new ethers.providers.JsonRpcProvider(RPC_PROVIDERS[chainId]);
        return opWsProvider
    }
}
export const callbackTrade = async () => {
    // console.log("callbackTrade")
    const wsProvider = getWsProvider();
    // console.log("wsProvider", wsProvider)
    if (!wsProvider) {
        return;
    }
    const wsPools = new ethers.Contract(pool_contract_address, Pools.abi, wsProvider);
    console.log("wsPools", wsPools)
    // console.log("exchangeRef", exchangeRef)
    const callExchangeRef = (method, ...args) => {
        console.log("method", method, args)
        if (!exchangeRef) {
            console.log(1111)
            return;
        }
        console.log(2222)
        exchangeRef?.[method](...args);
    };
    // const onCreatePool = (...args) => callExchangeRef("onCreatePool", ...args);
    // const onOpenPool = (...args) => callExchangeRef("onOpenPool", ...args);
    // const onUpdateGolobalFeesRate = (...args) => callExchangeRef("onUpdateGolobalFeesRate", ...args);
    // const onUpdatePoolFeesRate = (...args) => callExchangeRef("onUpdatePoolFeesRate", ...args);
    // const onUpdateGOVFeesRate = (...args) => callExchangeRef("onUpdateGOVFeesRate", ...args);
    // const onWithdrawFee = (...args) => callExchangeRef("onWithdrawFee", ...args);
    // const onUpdateGov = (...args) => callExchangeRef("onUpdateGov", ...args);
    // const onUpdateDev = (...args) => callExchangeRef("onUpdateDev", ...args);

    // wsPools.on("CreatePool", onCreatePool);
    // wsPools.on("OpenPool", onOpenPool);
    // wsPools.on("UpdateGolobalFeesRate", onUpdateGolobalFeesRate);
    // wsPools.on("UpdatePoolFeesRate", onUpdatePoolFeesRate);
    // wsPools.on("UpdateGOVFeesRate", onUpdateGOVFeesRate);
    // wsPools.on("WithdrawFee", onWithdrawFee);
    // wsPools.on("UpdateGov", onUpdateGov);
    // wsPools.on("UpdateDev", onUpdateDev);

    wsPools.on("CreatePool", (oldValue, newValue, event) => {
        console.log("onCreatePool=", oldValue, newValue, event)
        console.log(oldValue, newValue);
    });
    // 得到当前block
    // const block = await wsProvider.getBlockNumber()
    // console.log(`当前区块高度: ${block}`);
    // console.log(`打印事件详情:`);
    // const transferEvents = await wsPools.queryFilter('Transfer', block - 10, block)
    // // 打印第1个Transfer事件
    // console.log(transferEvents[0])
}