@suiware/ai-tools/dist/chunk-BF2YFHSF.mjs

Pluggable tools for Vercel AI SDK which allow AI assistants to interact with Sui Network and perform various actions.

import { getSetting, SuiService, __async, __pow } from './chunk-UXHRSDY6.mjs';
import BigNumber from 'bignumber.js';
import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
import { NAVISDKClient, NAVX, Sui, vSui, USDT, WETH, CETUS, haSui, WBTC, AUSD, wUSDC, nUSDC, ETH, USDY, NS, LorenzoBTC, DEEP, FDUSD, BLUE, BUCK, suiUSDT, stSUI, suiBTC, WSOL, LBTC, WAL } from 'navi-sdk';

function formatBalance(balance, decimals) {
  return BigNumber(balance.toString()).shiftedBy(-decimals).toFixed(8);
}
function disableConsoleLog() {
  const originalConsoleLog = console.log;
  console.log = () => {
  };
  return originalConsoleLog;
}
function enableConsoleLog(originalConsoleLog) {
  console.log = originalConsoleLog;
}
var SUPPORTED_COINS = [
  NAVX,
  Sui,
  vSui,
  USDT,
  WETH,
  CETUS,
  haSui,
  WBTC,
  AUSD,
  wUSDC,
  nUSDC,
  ETH,
  USDY,
  NS,
  LorenzoBTC,
  DEEP,
  FDUSD,
  BLUE,
  BUCK,
  suiUSDT,
  stSUI,
  suiBTC,
  WSOL,
  LBTC,
  WAL
];

// src/services/NaviService.ts
var NaviService = class _NaviService {
  constructor() {
    const privateKey = getSetting("SUI_PRIVATE_KEY");
    if (!SuiService.isValidPrivateKey(privateKey)) {
      throw new Error("Invalid SUI_PRIVATE_KEY in the config");
    }
    const suiNetwork = getSetting("SUI_NETWORK");
    this.naviClient = new NAVISDKClient({
      privateKeyList: [privateKey],
      networkType: suiNetwork
    });
    this.account = this.naviClient.accounts[0];
    this.suiClient = new SuiClient({
      url: getFullnodeUrl(suiNetwork)
    });
  }
  getSuiClient() {
    return this.suiClient;
  }
  getAddress() {
    return this.account.address;
  }
  getAllBalances() {
    return __async(this, null, function* () {
      const allBalances = yield this.naviClient.getAllBalances();
      return _NaviService.getSupportedCoins().map((x) => ({
        [_NaviService.naviUsdcToUsdc(x.symbol)]: allBalances[x.address]
      }));
    });
  }
  swap(sourceToken, targetToken, amount) {
    return __async(this, null, function* () {
      if (this.naviClient.networkType !== "mainnet") {
        throw new Error("Only mainnet is supported");
      }
      const sourceTokenMetadata = _NaviService.getSupportedCoinBySymbol(sourceToken);
      const targetTokenMetadata = _NaviService.getSupportedCoinBySymbol(targetToken);
      const amountIn = (typeof amount === "string" ? parseFloat(amount) : amount) * __pow(10, sourceTokenMetadata.decimal);
      return yield this.account.swap(
        sourceTokenMetadata.address,
        targetTokenMetadata.address,
        amountIn,
        0
      );
    });
  }
  transfer(token, targetAddress, amount) {
    return __async(this, null, function* () {
      const sourceTokenMetadata = _NaviService.getSupportedCoinBySymbol(token);
      const amountIn = (typeof amount === "string" ? parseFloat(amount) : amount) * __pow(10, sourceTokenMetadata.decimal);
      return yield this.account.sendCoin(
        sourceTokenMetadata.address,
        targetAddress,
        amountIn
      );
    });
  }
  getWalletNonZeroCoins() {
    return __async(this, null, function* () {
      const allBalances = yield this.suiClient.getAllBalances({
        owner: this.account.address
      });
      const coinBalances = {};
      for (const { coinType, totalBalance } of allBalances) {
        if (parseFloat(totalBalance) == 0) {
          continue;
        }
        const coinInfo = this.getSupportedCoinByAddress(coinType);
        if (coinInfo) {
          coinBalances[coinInfo.symbol] = formatBalance(
            totalBalance,
            coinInfo.decimal
          );
          continue;
        }
        const coinMetadata = yield this.fetchCoinMetadata(coinType);
        if (coinMetadata) {
          coinBalances[coinMetadata.symbol] = formatBalance(
            totalBalance,
            coinMetadata.decimals
          );
          continue;
        }
        const decimal = yield this.account.getCoinDecimal(coinType);
        coinBalances[coinType] = formatBalance(totalBalance, decimal);
      }
      return coinBalances;
    });
  }
  getWalletBalance() {
    return __async(this, null, function* () {
      return yield this.naviClient.accounts[0].getWalletBalance();
    });
  }
  static getSupportedCoins() {
    return SUPPORTED_COINS;
  }
  static isSupportedCoin(symbol) {
    return this.getSupportedCoins().some(
      (coin) => this.naviUsdcToUsdc(coin.symbol).toUpperCase() === symbol.toUpperCase()
    );
  }
  static getSupportedCoinBySymbol(symbol) {
    return this.getSupportedCoins().find(
      (coin) => this.naviUsdcToUsdc(coin.symbol).toUpperCase() === symbol.toUpperCase()
    );
  }
  static getMissingSupportedCoin(symbol) {
    return this.getSupportedCoins().find(
      (coin) => this.naviUsdcToUsdc(coin.symbol).toUpperCase() !== symbol.toUpperCase()
    );
  }
  getSupportedCoinByAddress(address) {
    const naviCoins = _NaviService.getSupportedCoins();
    return naviCoins.find((x) => x.address === address);
  }
  fetchCoinMetadata(coinType) {
    return __async(this, null, function* () {
      return this.suiClient.getCoinMetadata({ coinType });
    });
  }
  static naviUsdcToUsdc(symbol) {
    return symbol === "nUSDC" ? "USDC" : symbol;
  }
};

export { NaviService, disableConsoleLog, enableConsoleLog };
//# sourceMappingURL=chunk-BF2YFHSF.mjs.map
//# sourceMappingURL=chunk-BF2YFHSF.mjs.map