navi-sdk/examples/liquidation-bot/liquidation-bot.ts

The NAVI SDK Client provides tools for interacting with the Sui blockchain networks, designed for handling transactions, accounts, and smart contracts efficiently. This documentation covers the setup, account management, and transaction handling within th

import { NAVISDKClient } from "navi-sdk";
import { depositCoin, withdrawCoin, borrowCoin, flashloan, repayFlashLoan, SignAndSubmitTXB, liquidateFunction } from 'navi-sdk/dist/libs/PTB'
import dotenv from 'dotenv';
import { Transaction } from "@mysten/sui/transactions";
import { CETUS, pool, Sui, wUSDC, USDT, vSui } from 'navi-sdk/dist/address';
import { PoolConfig, Pool, CoinInfo } from 'navi-sdk/dist/types';
import { AccountManager } from "navi-sdk/dist/libs/AccountManager"


dotenv.config();

const accountMnemonic = process.env.mnemonic;
const client = new NAVISDKClient({ mnemonic: accountMnemonic });
const account = client.accounts[0];
const sender = account.address;

//Set UP Zone
const to_pay_coin: CoinInfo = wUSDC;
const to_liquidate_address = '0xcaa4af4b06b6eed841bbd254cb19a3fcd64e3e902fe2bcbd4e02f6f9711e0c43';
const collectral_coin: CoinInfo = Sui;
//End of Set UP Zone
const txb = new Transaction();
let [coinObj, to_liquidate_amount] = await getCoinObj(txb,account, to_pay_coin);


async function monitorAndExecute(txb: any, account: any, to_liquidator_address: string): Promise<void> {
    const healthFactorStartThreshold = 1.003;
    const healthFactorStopThreshold = 1.02;
    const monitorInterval = 20000; // Interval for monitoring in milliseconds (10 seconds)
    let executionInterval = 100; // Interval for execution attempts in milliseconds (0.1 seconds)
    let attemptCount = 0; // Track the number of attempts

    // Function to get the current health factor
    const getCurrentHealthFactor = async (): Promise<number> => {
        return account.getHealthFactor(to_liquidator_address)
            .then((result: number) => {
                console.log('Current HF: ', result);
                return result;
            }).catch((error: any) => {
                console.error('Error fetching health factor:', error);
                throw error; // Propagate the error
            });
    };

    // Function to execute the operation
    const executeOperation = async () => {
        attemptCount++; // Increment attempt count
        console.log(`Attempt ${attemptCount}...`);

        try {
            const result = await account.liquidate(to_pay_coin, to_liquidate_address, collectral_coin, to_liquidate_amount)
            console.log('Success:', result);
            return 'success'; // Operation succeeded
        } catch (error) {
            return 'retry'; // Operation failed, but will retry
        }
    };

    return new Promise((resolve, reject) => {
        const monitorOrExecute = async () => {
            try {
                const healthFactor = await getCurrentHealthFactor();

                if (healthFactor > healthFactorStopThreshold) {
                    console.log(`Health Factor exceeds stop threshold (${healthFactorStopThreshold}). Stopping.`);
                    resolve(); // Stop the script
                    return;
                }

                if (healthFactor <= healthFactorStartThreshold) {
                    const result = await executeOperation();

                    if (result === 'success') {
                        console.log('Operation successful.');
                        resolve(); // Operation succeeded, stop script
                        return;
                    } else if (result === 'retry') {
                        setTimeout(monitorOrExecute, executionInterval); // Retry execution
                        return;
                    }
                } else {
                    console.log(`Health Factor is above the start threshold (${healthFactorStartThreshold}). Monitoring.`);
                    attemptCount = 0; // Reset attempt count when not in execution phase
                    setTimeout(monitorOrExecute, monitorInterval); // Go back to monitoring
                }
            } catch (error) {
                reject(error); // Handle errors
            }
        };

        monitorOrExecute(); // Start the process
    });
}

export async function getCoinObj(txb: Transaction,account: AccountManager, realCoin: CoinInfo) {

    let getCoinInfo = await account.getCoins(
        realCoin.address
    );
    let allBalance = await account.client.getBalance({owner: account.address, coinType: realCoin.address});
    
    if (getCoinInfo.data.length >= 2) {
        txb.setSender(account.address);
        let baseObj = getCoinInfo.data[0].coinObjectId;
        let i = 1;
        while (i < getCoinInfo.data.length) {
            txb.mergeCoins(baseObj, [getCoinInfo.data[i].coinObjectId]);
            i++;
        }
        SignAndSubmitTXB(txb, account.client, account.keypair);
    }

    let mergedCoin = getCoinInfo.data[0].coinObjectId;
    let { totalBalance } = allBalance;
    return [mergedCoin, totalBalance];
}

monitorAndExecute(txb, account, to_liquidate_address).then(() => {
    console.log('Operation completed or stopped due to health factor.');
}).catch(error => {
    console.error('Operation encountered an error:', error);
});