navi-sdk/test/dryrun_test.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 { Transaction } from '@mysten/sui/transactions';
import { SuiClient, SuiEvent } from '@mysten/sui/client';
import {
  buildSwapPTBFromQuote,
  Dex,
  NAVISDKClient,
  Quote,
  SwapOptions,
} from '../src';
import { createTransaction, handleTransactionResult } from './helper';
import { account } from './client';

const client = new NAVISDKClient({
  mnemonic: process.env.MNEMONIC,
  networkType: 'mainnet',
  numberOfAccounts: 5,
});
const accountManager = client.accounts[0];

const provider = new SuiClient({
  url: 'https://fullnode.mainnet.sui.io',
});

function returnMergedCoins(txb: Transaction, coins: any[], amount: number) {
  if (coins.length < 2) {
    return txb.object(coins[0].coinObjectId);
  }

  let mergedBalance = 0;
  const mergeList: string[] = [];
  coins
    .sort((a, b) => Number(b.balance) - Number(a.balance))
    .slice(1)
    .forEach((coin) => {
      if (mergedBalance >= amount) {
        return;
      }
      mergedBalance += Number(coin.balance);
      mergeList.push(coin.coinObjectId);
    });
  const baseObj = coins[0].coinObjectId;
  txb.mergeCoins(baseObj, mergeList);

  return txb.object(baseObj);
}

const getCoinBalance = (coins: any[]) => {
  const totalBalance = coins.reduce(
    (sum, coin) => sum + BigInt(coin.balance),
    BigInt(0)
  );
  return totalBalance;
};

const test = async (
  coinFromAddress: string,
  coinToAddress: string,
  amountIn: number,
  address: string,
  swapOptions: SwapOptions
) => {
  const coins = await accountManager.fetchCoins(address, coinFromAddress);
  const balance = getCoinBalance(coins as unknown as any[]);
  if (balance === BigInt(0)) {
    console.error(
      'No token balance',
      address,
      coins.length,
      coinFromAddress
    );
    return `No token balance: ${address}, ${coins.length}, ${coinFromAddress}`;
  }
  const txb = createTransaction(account);

  txb.setGasBudget(1 * 10 ** 9);

  let coinIn;
  if (
    coinFromAddress === '0x2::sui::SUI' ||
    coinFromAddress ===
    '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'
  ) {
    coinIn = txb.splitCoins(txb.gas, [txb.pure.u64(amountIn)]);
  } else {
    const mergedCoins = returnMergedCoins(
      txb,
      coins as unknown as any[],
      amountIn
    );
    coinIn = txb.splitCoins(mergedCoins, [txb.pure.u64(amountIn)]);
  }

  const router = await client.getQuote(
    coinFromAddress,
    coinToAddress,
    amountIn,
    undefined,
    swapOptions
  );
  const coinOut = await buildSwapPTBFromQuote(
    address,
    txb,
    0,
    coinIn,
    router,
        /*referral=*/ undefined,
        /*ifPrint=*/ false,
    undefined,
    swapOptions
  );
  txb.transferObjects([coinOut], address);

  if (address) {
    txb.setSender(address);
  }

  const dryRunTxBytes: Uint8Array = await txb.build({
    client: provider,
  });

  const tsRes = await handleTransactionResult(txb, accountManager, "test", false);
  console.log(tsRes);
  // const txEffects = await provider?.dryRunTransactionBlock({
  //   transactionBlock: dryRunTxBytes,
  // });

  // const slippageEvent = txEffects?.events?.find((event: SuiEvent) => {
  //   return event.type.includes('::slippage::SwapEvent');
  // });

  // if (slippageEvent) {
  //   const newRouter = { ...router } as Quote;
  //   newRouter.amount_out = (
  //     slippageEvent.parsedJson as { amount_out: string }
  //   ).amount_out;
  //   console.log(newRouter);
  // }
};

test(
  '0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT',
  '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC',
  1e6 * 0.1,
  'some address',
  {
    baseUrl: 'http://localhost:5000/find_routes',
    dexList: [Dex.MOMENTUM],
    byAmountIn: true,
    depth: 3,
  }
);