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_RESERVE_LP_ADDRESSES,
    WETH_ADDRESSES,
} from "../constants/addresses";
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_RESERVE_LP_ADDRESSES[chainId];
            break;
        case "RESERVE_FTSO":
            address = FTSO_RESERVE_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_RESERVE_LP_ADDRESSES[chainId]:
            icons = ["WETH", "FTSO"];
            break;
        default:
            icons = [""]
    }
    return icons;
}

export const getChainTokenNames = (chainId, address) => {
    let icons = [undefined];
    switch (address) {
        case FTSO_RESERVE_LP_ADDRESSES[chainId]:
            icons = [undefined, "WETH"];
            break;
        case RESERVE_ADDRESSES[chainId]:
            icons = [undefined]
            break;
        default:
            icons = ["WETH"]
    }
    return icons;
}

export const getBondNameDisplayName = (chainId, tokenAddress, baseTokenSymbol) => {
    let stringValue = tokenNameConverter(chainId, "WETH")
    if (tokenAddress.toUpperCase() === FTSO_RESERVE_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_RESERVE_LP_ADDRESSES[chainId]:
            purchaseUrl += `?pool=true&from=${RESERVE_ADDRESSES[chainId]}&to=${FTSO_ADDRESSES[chainId]}`;
            break;
    }
    return purchaseUrl;
}

export const executeOnChainTransaction = async ({
    chainId,
    abi,
    address,
    functionName,
    args,
    account,
    messages,
    value
}) => {
    try {
        const { request } = await simulateContract(config, {
            abi,
            address,
            functionName,
            args,
            account,
            chainId,
            value,
        });

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

        toast.success(messages.successMsg);

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

export const executePapiBareTransaction = async ({
    client,
    bareTx,
    messages = {
        loadingMsg: "Broadcasting transaction to available peers...",
        inBlockMsg: "Transaction included in block, waiting for finality...",
        successMsg: "Transaction successfully finalized!",
        errorMsg: "Transaction failed.",
    },
}) => {
    try {
        return await new Promise((resolve, reject) => {
            const subscription = client.submitAndWatch(bareTx).subscribe({
                next: (event) => {
                    if (event.type === "broadcasted") {
                        toast.success(messages.loadingMsg);
                    } else if (event.type === "inBestBlock") {
                        toast.success(messages.inBlockMsg);
                    } else if (event.type === "finalized") {
                        toast.success(messages.successMsg);
                        subscription.unsubscribe();
                        resolve(event);
                    }
                },
                error: (err) => {
                    toast.error(`${messages.errorMsg} ${err.message || err}`);
                    subscription.unsubscribe();
                    reject(err);
                },
            });
        });
    } catch (err) {
        console.error("Bare PAPI Transaction failed:", err);
        return undefined;
    }
};