navi-sdk/src/libs/Bridge/index.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 {
  Chain,
  Token,
  BridgeSwapOptions,
  BridgeSwapQuote,
  BridgeSwapTransaction,
} from "../../types";
import * as mayan from "./providers/mayan";
import { WalletConnection } from "./providers/mayan";
import { apiInstance, config } from "./config";

export { config };

export async function getSupportChains(): Promise<Chain[]> {
  const res = await apiInstance.get<{
    data: {
      chains: Chain[];
    };
  }>("/chains/list");
  return res.data.data.chains;
}

export async function getSupportTokens(
  chainId: number,
  page: number = 1,
  pageSize: number = 100
): Promise<Token[]> {
  const res = await apiInstance.get<{
    data: {
      list: Token[];
    };
  }>("/coins/support-token-list", {
    params: {
      chain: chainId,
      page,
      pageSize,
      scene: "bridge",
    },
  });
  return res.data.data.list;
}

export async function searchSupportTokens(
  chainId: number,
  keyword: string
): Promise<Token[]> {
  const res = await apiInstance.get<{
    data: {
      list: Token[];
    };
  }>("/coins/search", {
    params: {
      chain: chainId,
      keyword,
      page: 1,
      pageSize: 30,
      scene: "bridge",
    },
  });
  return res.data.data.list;
}

export async function getQuote(
  from: Token,
  to: Token,
  amount: string | number,
  options?: BridgeSwapOptions
) {
  const res = await apiInstance.get<{
    data: {
      routes: BridgeSwapQuote[];
    };
  }>("/bridge-swap/find_routes", {
    params: {
      from: from.address,
      to: to.address,
      fromChain: from.chainId,
      toChain: to.chainId,
      amount,
      slippageBps: options?.slippageBps,
      referrerBps: options?.referrerBps,
    },
  });
  // temporary fix 
  const rtn = res.data.data;
  rtn.routes.forEach((router: any) => {
    if (router.from_token.chain) {
      router.from_token.chainId = parseInt(router.from_token.chain);
    }
    if (router.to_token.chain) {
      router.to_token.chainId = parseInt(router.to_token.chain);
    }
  })
  return rtn
}

export async function getTransaction(hash: string) {
  const res = await apiInstance.get<{
    data: {
      transaction: BridgeSwapTransaction;
    };
  }>(`/bridge-swap/transaction/${hash}`);
  return res.data.data.transaction;
}

export async function getWalletTransactions(
  address: string,
  page: number = 1,
  limit: number = 10
) {
  const res = await apiInstance.get<{
    data: {
      transactions: BridgeSwapTransaction[];
    };
  }>(`/bridge-swap/transactions/list`, {
    params: {
      address,
      page,
      limit,
    },
  });
  return res.data.data;
}

export async function swap(
  quote: BridgeSwapQuote,
  fromAddress: string,
  toAddress: string,
  walletConnection: WalletConnection,
  referrerAddresses?: {
    sui?: string;
    evm?: string;
    solana?: string;
  }
): Promise<BridgeSwapTransaction> {
  const startAt = new Date().toISOString();
  const hash = await mayan.swap(
    quote,
    fromAddress,
    toAddress,
    walletConnection,
    referrerAddresses
  );
  const endAt = new Date().toISOString();
  const sourceToken = {
    address: quote.from_token.address,
    symbol: quote.from_token.symbol,
    decimals: quote.from_token.decimals,
  };
  const destToken = {
    address: quote.to_token.address,
    symbol: quote.to_token.symbol,
    decimals: quote.to_token.decimals,
  };
  return {
    id: hash,
    status: "processing",
    lastUpdateAt: endAt,
    sourceChainId: quote.from_token.chainId,
    destChainId: quote.to_token.chainId,
    walletSourceAddress: fromAddress,
    walletDestAddress: toAddress,
    totalFeeAmount: quote.total_fee,
    sourceToken: quote.from_token,
    destToken: quote.to_token,
    bridgeFromAmount: quote.amount_in,
    bridgeToAmount: quote.amount_out,
    bridgeStartAt: startAt,
    bridgeEndAt: endAt,
    bridgeFeeAmount: "0",
    bridgeSourceTxHash: hash,
    bridgeDestTxHash: "",
    bridgeRefundTxHash: "",
    bridgeStatus: "processing",
    bridgeProvider: "mayan",
    bridgeFromToken: sourceToken,
    bridgeToToken: destToken,
    hasSwap: false,
  };
}