wative 1.0.1

package/src/web3.ts

@@ -0,0 +1,268 @@
+import Web3 from 'web3';
+import { excutePromiseFunction } from './utils';
+import { Connection, PublicKey } from "@solana/web3.js";
+import { getMint, getAssociatedTokenAddressSync } from "@solana/spl-token"
+import { Metaplex } from "@metaplex-foundation/js";
+
+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 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
+    }
+}