wative 1.2.8 → 1.2.11

package/src/web3.ts

@@ -1,415 +0,0 @@
-import Web3 from 'web3';
-import { chunkArray, excutePromiseFunction, sleep } from './utils';
-import { Connection, PublicKey } from "@solana/web3.js";
-import { getMint, getAssociatedTokenAddressSync } from "@solana/spl-token"
-import { Metaplex, token } from "@metaplex-foundation/js";
-import { BigNumber } from "bignumber.js";
-
-const chainIdAccountBalanceMap: any = {};
-
-export const getChainIdByEvm = async (rpc_url: string) => {
-    let web3 = new Web3(rpc_url);
-    let result = await excutePromiseFunction(web3.eth.getChainId, []);
-    return result;
-}
-
-export const getAccountBalanceInEvm = async (account: string, rpc_url: string) => {
-    const web3 = new Web3(rpc_url);
-    let result = await excutePromiseFunction(web3.eth.getBalance, [account]);
-    return result;
-}
-
-export const getAccountBalanceInSolana = async (account: string, rpc_url: string) => {
-    const connection = new Connection(rpc_url);
-    let result = await excutePromiseFunction(connection.getBalance.bind(connection), [new PublicKey(account)]);
-    return result;
-}
-
-export const getTokenInfoInEvm = async (token_address: string, rpc_url: string) => {
-    const web3 = new Web3(rpc_url);
-    const erc20 = new web3.eth.Contract([
-        {
-            "constant": true,
-            "inputs": [],
-            "name": "symbol",
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "string"
-                }
-            ],
-            "payable": false,
-            "stateMutability": "view",
-            "type": "function"
-        },
-        {
-            "constant": true,
-            "inputs": [],
-            "name": "name",
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "string"
-                }
-            ],
-            "payable": false,
-            "stateMutability": "view",
-            "type": "function"
-        },
-        {
-            "constant": true,
-            "inputs": [],
-            "name": "decimals",
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "uint256"
-                }
-            ],
-            "payable": false,
-            "stateMutability": "view",
-            "type": "function"
-        }
-    ], token_address);
-
-    let sysmbol_result = await excutePromiseFunction(erc20.methods.symbol().call.bind(erc20), []);
-    let name_result = await excutePromiseFunction(erc20.methods.name().call.bind(erc20), []);
-    let decimals_result = await excutePromiseFunction(erc20.methods.decimals().call.bind(erc20), []);
-
-    if (!sysmbol_result.status || !name_result.status || !decimals_result.status) {
-        return {
-            status: false,
-            output: "Failed to get token info"
-        }
-    }
-    return {
-        status: true,
-        output: {
-            symbol: sysmbol_result.output,
-            name: name_result.output,
-            decimals: decimals_result.output
-        }
-    }
-}
-
-export const getTokenInfoInSolana = async (token_address: string, rpc_url: string) => {
-    const connection = new Connection(rpc_url);
-    const metaplex = Metaplex.make(connection);
-    const mintAddress = new PublicKey(token_address);
-    const token_mint_info = await excutePromiseFunction(getMint, [connection, mintAddress]);
-    let result = {
-        status: true,
-        output: {
-            symbol: "",
-            name: "",
-            decimals: ""
-        }
-    }
-
-    if (!token_mint_info.status) {
-        return {
-            status: false,
-            output: "Failed to get token decimals"
-        };
-    }
-
-    result.output.decimals = token_mint_info.output.decimals;
-    try {
-        const metadataAccount = metaplex
-            .nfts()
-            .pdas()
-            .metadata({ mint: mintAddress });
-        const metadataAccountInfo = await connection.getAccountInfo(metadataAccount);
-
-        if (metadataAccountInfo) {
-            const token = await metaplex.nfts().findByMint({ mintAddress: mintAddress });
-            result.output.name = token.name;
-            result.output.symbol = token.symbol;
-        }
-
-    } catch (error) {
-        return {
-            status: false,
-            output: "Failed to get token name"
-        }
-    }
-    return result;
-}
-
-export const getTokenBalanceInEvm = async (account: string, token_address: string, rpc_url: string) => {
-    const web3 = new Web3(rpc_url);
-    const erc20 = new web3.eth.Contract([
-        {
-            "constant": true,
-            "inputs": [
-                {
-                    "name": "who",
-                    "type": "address"
-                }
-            ],
-            "name": "balanceOf",
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "uint256"
-                }
-            ],
-            "payable": false,
-            "stateMutability": "view",
-            "type": "function"
-        }
-    ], token_address);
-    let balance_result = await excutePromiseFunction(erc20.methods.balanceOf(account).call.bind(erc20), []);
-    if (!balance_result.status) {
-        return {
-            status: false,
-            output: "Failed to get token balance"
-        }
-    }
-    return {
-        status: true,
-        output: balance_result.output
-    }
-}
-
-export const getTokenBalanceInSolana = async (account: string, token_address: string, rpc_url: string) => {
-    const connection = new Connection(rpc_url);
-    const tokenAccount = getAssociatedTokenAddressSync(new PublicKey(token_address), new PublicKey(account));
-    let balance_result = await excutePromiseFunction(connection.getTokenAccountBalance.bind(connection), [tokenAccount]);
-    if (!balance_result.status) {
-        if (balance_result.output.includes("could not find account")) {
-            return {
-                status: true,
-                output: "0"
-            }
-        }
-        return {
-            status: false,
-            output: "Failed to get token balance"
-        }
-    }
-    return {
-        status: true,
-        output: balance_result.output.value.amount
-    }
-}
-
-export const getCodeInEvm = async (account: string, rpc_url: string) => {
-    const web3 = new Web3(rpc_url);
-    let code_result = await excutePromiseFunction(web3.eth.getCode.bind(web3), [account]);
-    if (!code_result.status) {
-        return {
-            status: false,
-            output: "Failed to get code"
-        }
-    }
-    return {
-        status: true,
-        output: code_result.output
-    }
-}
-
-export const getTransferTokenData = async (to: string, amount: string, rpc_url: string) => {
-    const web3 = new Web3(rpc_url);
-    const transfer_token_abi_data = web3.eth.abi.encodeFunctionCall({
-        "constant": false,
-        "inputs": [
-            {
-                "name": "_to",
-                "type": "address"
-            },
-            {
-                "name": "_value",
-                "type": "uint256"
-            }
-        ],
-        "name": "transfer",
-        "outputs": [],
-        "payable": false,
-        "stateMutability": "nonpayable",
-        "type": "function"
-    }, [to, amount]);
-
-    return transfer_token_abi_data;
-}
-
-export const getPrioritizationFee = async (rpc_url: string) => {
-    const connection = new Connection(rpc_url);
-    let result = await excutePromiseFunction(connection.getRecentPrioritizationFees.bind(connection), []);
-    if (!result.status) {
-        return {
-            status: false,
-            output: "Failed to get recent prioritization fees"
-        }
-    }
-
-    let prioritization_fee_list = result.output;
-    const fees = prioritization_fee_list.map((fee: any) => fee.prioritizationFee).sort();
-    const prioritization_fee = fees.length > 0 ? Math.ceil(fees.reduce((acc: any, cur: any) => acc + cur) / fees.length) : 1000;
-
-    return {
-        status: true,
-        output: prioritization_fee
-    }
-}
-
-export const getLatestBlockhash = async (rpc_url: string) => {
-    const connection = new Connection(rpc_url);
-    let result = await excutePromiseFunction(connection.getLatestBlockhash.bind(connection), [{
-        commitment: "finalized"
-    }]);
-    if (!result.status) {
-        return {
-            status: false,
-            output: "Failed to get latest blockhash"
-        }
-    }
-    return {
-        status: true,
-        output: result.output
-    }
-}
-
-export const getAccountInfoInSolana = async (account: string, rpc_url: string) => {
-    const connection = new Connection(rpc_url);
-    let result = await excutePromiseFunction(connection.getAccountInfo.bind(connection), [
-        new PublicKey(account.toString())
-    ]);
-    if (!result.status) {
-        return {
-            status: false,
-            output: "Failed to get account info"
-        }
-    }
-    return {
-        status: true,
-        output: result.output
-    }
-}
-
-export const updateBalance = async (account_address_list: string[], token_address: string, chain_id: string, rpc_url: string, is_evm: boolean) => {
-    let accountBalanceMap: any;
-    if (chain_id in chainIdAccountBalanceMap) {
-        accountBalanceMap = chainIdAccountBalanceMap[chain_id][token_address] || {};
-    } else {
-        chainIdAccountBalanceMap[chain_id] = {};
-        accountBalanceMap = {};
-    }
-
-    for (const account of account_address_list) {
-        if (!account) {
-            continue;
-        }
-
-        if (!(account in accountBalanceMap)) {
-            let result: any;
-            if (token_address === "0") {
-                if (is_evm) {
-                    result = await getAccountBalanceInEvm(account, rpc_url);
-                } else {
-                    result = await getAccountBalanceInSolana(account, rpc_url);
-                }
-            } else {
-                if (is_evm) {
-                    result = await getTokenBalanceInEvm(account, token_address, rpc_url);
-
-                } else {
-                    result = await getTokenBalanceInSolana(account, token_address, rpc_url);
-                }
-            }
-
-            if (result.status) {
-                accountBalanceMap[account] = result.output;
-            }
-            await sleep(200);
-        }
-    }
-
-    chainIdAccountBalanceMap[chain_id][token_address] = accountBalanceMap;
-
-    return chainIdAccountBalanceMap;
-}
-
-export const getTokenBalance = (
-    chain_id: string,
-    account_address_list: any,
-    asset_info_list: any,
-    network_info: any
-) => {
-    let batchAccountBalanceOf: any = {};
-
-    if (!(chain_id in chainIdAccountBalanceMap)) {
-        return batchAccountBalanceOf;
-    }
-
-    asset_info_list.unshift({
-        address: "0",
-        name: network_info.nativeCurrency.name,
-        symbol: network_info.nativeCurrency.symbol,
-        decimals: network_info.nativeCurrency.decimals,
-        display_decimals: 4
-    });
-    let account_address_list_len = account_address_list.length;
-    for (let i = 0; i < account_address_list_len; i++) {
-        let account_address = account_address_list[i];
-
-        if (!account_address) {
-            continue;
-        }
-
-        for (let j = 0; j < asset_info_list.length; j++) {
-            let asset_info = asset_info_list[j];
-            let token_balance = "0";
-            if (!chainIdAccountBalanceMap[chain_id][asset_info.address]) {
-                continue;
-            }
-
-            if (account_address in chainIdAccountBalanceMap[chain_id][asset_info.address]) {
-                let balance = new BigNumber(chainIdAccountBalanceMap[chain_id][asset_info.address][account_address]);
-                token_balance = balance.dividedBy(10 ** asset_info.decimals).toFixed(asset_info.display_decimals || 4, BigNumber.ROUND_FLOOR);
-            }
-            if (!batchAccountBalanceOf[account_address]) {
-                batchAccountBalanceOf[account_address] = {};
-            }
-            batchAccountBalanceOf[account_address][asset_info.symbol] = token_balance;
-        }
-    }
-
-    return batchAccountBalanceOf;
-}
-
-export const deleteTokenBalance = (chain_id: string, account_address_list: string[], token_address_list: string[]) => {
-    for (let i = 0; i < account_address_list.length; i++) {
-        let account_address = account_address_list[i];
-        for (let j = 0; j < token_address_list.length; j++) {
-            let token_address = token_address_list[j];
-            try {
-                delete chainIdAccountBalanceMap[chain_id][token_address][account_address];
-            } catch (err) { }
-        }
-    }
-}
-
-export const batchUpdateUserTokenBalance = async (chain_id: string, account_address: string, token_address_list: string[], rpc_url: string, is_evm: boolean) => {
-    for (let i = 0; i < token_address_list.length; i++) {
-        let token_address = token_address_list[i];
-        await updateBalance([account_address], token_address, chain_id, rpc_url, is_evm);
-    }
-}
-
-export const batchHasTokenBalance = (chain_id: string, account_address_list: string[]) => {
-    let hasAccount = 0;
-    if (chain_id in chainIdAccountBalanceMap) {
-        if ("0" in chainIdAccountBalanceMap[chain_id]) {
-            for (let i = 0; i < account_address_list.length; i++) {
-                if (account_address_list[i] in chainIdAccountBalanceMap[chain_id]["0"]) {
-                    hasAccount += 1;
-                }
-            }
-        }
-    }
-    if (hasAccount === 0) {
-        return false
-    }
-    return hasAccount / account_address_list.length > 0.8;
-}