ghost-dao-interface/src/hooks/helpers.js

import toast from "react-hot-toast";
import { simulateContract, writeContract, waitForTransactionReceipt } from "@wagmi/core";

import {
    RESERVE_ADDRESSES,
    FTSO_ADDRESSES,
    STNK_ADDRESSES,
    GHST_ADDRESSES,
    FTSO_DAI_LP_ADDRESSES,
    WETH_ADDRESSES,
} from "../constants/addresses";
import { isNetworkLegacyType } from "../constants";
import { config } from "../config";

import { tokenNameConverter } from "../helpers/tokenConverter";

import { abi as DaiAbi } from "../abi/Reserve.json";
import { abi as FatsoAbi } from "../abi/Fatso.json";
import { abi as StinkyAbi } from "../abi/Stinky.json";
import { abi as GhostAbi } from "../abi/Ghost.json";
import { abi as Erc20Abi } from "../abi/ERC20.json";
import { abi as WethAbi } from "../abi/WETH9.json";

// TBD: should be extended on new tokens
export const getTokenAbi = (name) => {
    let abi = Erc20Abi;
    switch (name?.toUpperCase()) {
        case "DAI":
            abi = DaiAbi;
            break;
        case "GDAI":
            abi = DaiAbi;
            break;
        case "RESERVE":
            abi = DaiAbi;
            break;
        case "FTSO":
            abi = FatsoAbi;
            break;
        case "ECSPR":
            abi = FatsoAbi;
            break;
        case "STNK":
            abi = StinkyAbi;
            break;
        case "SCSPR":
            abi = StinkyAbi;
            break;
        case "GHST":
            abi = GhostAbi;
            break;
        case "CSPR":
            abi = GhostAbi;
            break;
        case "WETH":
            abi = WethAbi;
            break;
        case "WMWETH":
            abi = WethAbi;
            break;
    }
    return abi;
}

// TBD: should be extended on new tokens
export const getTokenDecimals = (name) => {
    let decimals = 18;
    switch (name?.toUpperCase()) {
        case "DAI":
            decimals = 18;
            break;
        case "GDAI":
            decimals = 18;
            break;
        case "RESERVE":
            decimals = 18;
            break;
        case "FTSO":
            decimals = 9;
            break;
        case "ECSPR":
            decimals = 9;
            break;
        case "STNK":
            decimals = 9;
            break;
        case "SCSPR":
            decimals = 9;
            break;
        case "GHST":
            decimals = 18;
            break;
        case "CSPR":
            decimals = 18;
            break;
        case "WETH":
            decimals = 18;
            break;
        case "WMWETH":
            decimals = 18;
            break;
    }
    return decimals;
}

// TBD: should be extended on new tokens
export const getTokenAddress = (chainId, name) => {
    let address = name;
    switch (name?.toUpperCase()) {
        case "DAI":
            address = RESERVE_ADDRESSES[chainId];
            break;
        case "GDAI":
            address = RESERVE_ADDRESSES[chainId];
            break;
        case "RESERVE":
            address = RESERVE_ADDRESSES[chainId];
            break;
        case "FTSO":
            address = FTSO_ADDRESSES[chainId];
            break;
        case "ECSPR":
            address = FTSO_ADDRESSES[chainId];
            break;
        case "STNK":
            address = STNK_ADDRESSES[chainId];
            break;
        case "SCSPR":
            address = STNK_ADDRESSES[chainId];
            break;
        case "GHST":
            address = GHST_ADDRESSES[chainId];
            break;
        case "CSPR":
            address = GHST_ADDRESSES[chainId];
            break;
        case "GDAI_FTSO":
            address = FTSO_DAI_LP_ADDRESSES[chainId];
            break;
        case "RESERVE_FTSO":
            address = FTSO_DAI_LP_ADDRESSES[chainId];
            break;
        case "WETH":
            address = WETH_ADDRESSES[chainId];
            break;
        case "WETC":
            address = WETH_ADDRESSES[chainId];
            break;
        case "WMETC":
            address = WETH_ADDRESSES[chainId];
            break;
        case "ETH":
            address = undefined;
            break;
        case "METC":
            address = undefined;
            break;
    }
    return address;
}

export const getTokenIcons = (chainId, address) => {
    let icons = [""];
    switch (address) {
        case RESERVE_ADDRESSES[chainId]:
            icons = [tokenNameConverter(chainId, "WETH")];
            break;
        case FTSO_ADDRESSES[chainId]:
            icons = ["FTSO"];
            break;
        case STNK_ADDRESSES[chainId]:
            icons = "STNK";
            break;
        case GHST_ADDRESSES[chainId]:
            icons = ["GHST"];
            break;
        case FTSO_DAI_LP_ADDRESSES[chainId]:
            icons = ["FTSO", "WETH"];
            break;
        default:
            icons = [""]
    }
    return icons;
}

export const getBondNameDisplayName = (chainId, tokenAddress, baseTokenSymbol) => {
    let stringValue = tokenNameConverter(chainId, "WETH")
    if (tokenAddress.toUpperCase() === FTSO_DAI_LP_ADDRESSES[chainId].toUpperCase()) {
        stringValue = `${baseTokenSymbol}-${stringValue} LP`;
    }
    return stringValue;
}

export const getTokenPurchaseLink = (chainId, tokenAddress, chainName) => {
    let purchaseUrl = `https://app.dao.ghostchain.io/#/${chainName}/dex/uniswap`;
    switch (tokenAddress) {
        case RESERVE_ADDRESSES[chainId]:
            purchaseUrl = `https://app.dao.ghostchain.io/#/${chainName}/faucet`;
            if (chainId == 63) {
                purchaseUrl = `https://app.dao.ghostchain.io/#/${chainName}/wrapper`;
            }
            break;
        case FTSO_DAI_LP_ADDRESSES[chainId]:
            purchaseUrl += `?pool=true&from=${RESERVE_ADDRESSES[chainId]}&to=${FTSO_ADDRESSES[chainId]}`;
            break;
    }
    return purchaseUrl;
}

const sanitizeTransactionRequest = (request, isLegacy) => {
    const finalRequest = { ...request };
    if (isLegacy) {
        delete finalRequest.maxFeePerGas;
        delete finalRequest.maxPriorityFeePerGas;
    } else {
        delete finalRequest.gasPrice;
    }
    return finalRequest;
}

export const executeOnChainTransaction = async ({
    chainId,
    abi,
    address,
    functionName,
    args,
    account,
    messages,
    value
}) => {
    try {
        const isLegacy = isNetworkLegacyType(chainId);
        const { request } = await simulateContract(config, {
            abi,
            address,
            functionName,
            args,
            account,
            chainId,
            value,
            type: isLegacy ? 'legacy' : 'eip1559',
        });

        const finalRequest = sanitizeTransactionRequest(request, isLegacy);
        const txHash = await writeContract(config, finalRequest);
        await waitForTransactionReceipt(config, {
            hash: txHash,
            onReplaced: () => toast(messages.replacedMsg),
            chainId
        });

        toast.success(messages.successMsg);

        return txHash;
    } catch (err) {
        console.error(err);
        toast.error(messages.errorMsg)
        return undefined;
    }
}