Appearance
代码
walletConn.js-连接钱包使用到的方法:
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-连接钱包使用到的方法:
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-事件:
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])
}