add SUI to Allbridge Core (#428)

* add SUI to Allbridge Core

* fix Allbridge Core event data

Author: m-cote

package.json

@@ -40,6 +40,7 @@
     "@defillama/sdk": "^5.0.170",
     "@fastify/cors": "^9.0.1",
     "@graphql-typed-document-node/core": "^3.2.0",
+    "@mysten/sui": "^1.43.0",
     "@solana/web3.js": "^1.87.3",
     "async-retry": "^1.3.1",
     "axios": "^0.21.0",

src/adapters/allbridge-core/analyticsApi.ts

@@ -0,0 +1,53 @@
+import axios, { AxiosResponse } from 'axios';
+import { BigNumber } from 'ethers';
+import { EventData } from '../../utils/types';
+
+interface AnalyticsEvent {
+  blockTime: number;
+  txHash: string;
+  from: string;
+  to: string;
+  token: string;
+  amount: string;
+  isDeposit: boolean;
+}
+
+export async function getEventsFromAnalyticsApi(
+  chainCode: string,
+  fromBlock: number,
+  fromTimestampMs: number,
+  toBlock: number,
+  toTimestampMs: number
+): Promise<EventData[]> {
+  const from = new Date(fromTimestampMs).toISOString();
+  const to = new Date(toTimestampMs).toISOString();
+
+  let response: AxiosResponse<AnalyticsEvent[]>;
+  try {
+    response = await axios.get<AnalyticsEvent[]>(
+      `https://core.api.allbridgecoreapi.net/analytics/inflows?chain=${chainCode}&from=${from}&to=${to}`
+    );
+  } catch (e) {
+    console.error(`Error fetching ${chainCode} events`, e);
+    return [];
+  }
+
+  return response.data.map((event) => {
+    const blockTimeMs = event.blockTime * 1000;
+    return {
+      blockNumber: interpolateNumber(fromBlock, fromTimestampMs, toBlock, toTimestampMs, blockTimeMs),
+      txHash: event.txHash,
+      from: event.from,
+      to: event.to,
+      token: event.token,
+      amount: BigNumber.from(event.amount),
+      isDeposit: event.isDeposit,
+      timestamp: blockTimeMs,
+    }
+  });
+}
+
+function interpolateNumber(x1: number, y1: number, x2: number, y2: number, y: number): number {
+  const x = x1 + (x2 - x1) / (y2 - y1) * (y - y1);
+  return Math.round(x);
+}

src/adapters/allbridge-core/index.ts

@@ -1,4 +1,3 @@
-import axios, { AxiosResponse } from 'axios';
 import { BigNumber } from 'ethers';
 import { BridgeAdapter, PartialContractEventParams } from "../../helpers/bridgeAdapter.type";
 import { Chain } from "@defillama/sdk/build/general";
@@ -7,6 +6,8 @@ import { fromHex } from 'tron-format-address';
 import { getConnection } from '../../helpers/solana';
 import { getTxDataFromEVMEventLogs } from "../../helpers/processTransactions";
 import { getTxDataFromTronEventLogs } from './eventParsing';
+import { getEventsFromAnalyticsApi } from './analyticsApi';
+import { getClient as getSuiClient } from '../../helpers/sui';
 
 const adapterName = "allbridge-core";
 
@@ -59,6 +60,10 @@ const lpAddresses = {
   [chain: string]: string[];
 };
 
+const suiFullTokenAddressMap: Record<string, string> = {
+  "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7": "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+};
+
 const constructParams = (chain: string) => {
   let eventParams = [] as PartialContractEventParams[];
   const lps = lpAddresses[chain];
@@ -111,21 +116,6 @@ const constructParams = (chain: string) => {
     getTxDataFromEVMEventLogs(adapterName, chain as Chain, fromBlock, toBlock, eventParams);
 };
 
-interface SolanaEvent {
-  blockTime: number;
-  txHash: string;
-  from: string;
-  to: string;
-  token: string;
-  amount: string;
-  isDeposit: boolean;
-}
-
-function interpolateNumber(x1: number, y1: number, x2: number, y2: number, y: number): number {
-  const x = x1 + (x2 - x1) / (y2 - y1) * (y - y1);
-  return Math.round(x);
-}
-
 const getSolanaEvents = async (fromSlot: number, toSlot: number): Promise<EventData[]> => {
   const connection = getConnection();
   const timestampFrom = await connection.getBlockTime(fromSlot);
@@ -134,28 +124,18 @@ const getSolanaEvents = async (fromSlot: number, toSlot: number): Promise<EventD
   if (!timestampFrom || !timestampTo) {
     return [];
   }
-  const from = new Date(timestampFrom * 1000).toISOString();
-  const to = new Date(timestampTo * 1000).toISOString();
+  return await getEventsFromAnalyticsApi('SOL', fromSlot, timestampFrom * 1000, toSlot, timestampTo * 1000);
+};
 
-  let response: AxiosResponse<SolanaEvent[]>;
-  try {
-    response = await axios.get<SolanaEvent[]>(
-      `https://core.api.allbridgecoreapi.net/analytics/inflows?chain=SOL&from=${from}&to=${to}`
-    );
-  } catch (e) {
-    console.error("Error fetching Solana events", e);
-    return [];
-  }
+const getSuiEvents = async (fromCheckpointNumber: number, toCheckpointNumber: number): Promise<EventData[]> => {
+  const client = getSuiClient();
+  const fromCheckpoint = await client.getCheckpoint({ id: fromCheckpointNumber.toString() });
+  const fromTimestampMs = Number(fromCheckpoint.timestampMs);
+  const toCheckpoint = await client.getCheckpoint({ id: toCheckpointNumber.toString() });
+  const toTimestampMs = Number(toCheckpoint.timestampMs);
 
-  return response.data.map((event) => ({
-    blockNumber: interpolateNumber(fromSlot, timestampFrom, toSlot, timestampTo, event.blockTime),
-    txHash: event.txHash,
-    from,
-    to,
-    token: event.token,
-    amount: BigNumber.from(event.amount),
-    isDeposit: event.isDeposit,
-  }));
+  const eventData = await getEventsFromAnalyticsApi('SUI', fromCheckpointNumber, fromTimestampMs, toCheckpointNumber, toTimestampMs);
+  return eventData.map((data) => ({ ...data, token: suiFullTokenAddressMap[data.token] ?? data.token }));
 };
 
 function constructTronParams() {
@@ -225,6 +205,7 @@ const adapter: BridgeAdapter = {
   sonic: constructParams("sonic"),
   unichain: constructParams("unichain"),
   solana: getSolanaEvents,
+  sui: getSuiEvents,
 };
 
 export default adapter;

src/helpers/sui.ts

@@ -1,14 +1,14 @@
-// import {
-//   SuiClient,
-//   SuiTransactionBlockResponse,
-//   getFullnodeUrl,
-//   PaginatedTransactionResponse,
-// } from "@mysten/sui.js/client";
+import {
+  SuiClient,
+  SuiTransactionBlockResponse,
+  getFullnodeUrl,
+  PaginatedTransactionResponse,
+} from "@mysten/sui/client";
 
-// export const getClient = () => {
-//   const url = process.env.SUI_RPC ?? getFullnodeUrl("mainnet");
-//   return new SuiClient({ url });
-// };
+export const getClient = () => {
+  const url = process.env.SUI_RPC ?? getFullnodeUrl("mainnet");
+  return new SuiClient({ url });
+};
 
 // export const getTransactionBlocks = async (
 //   fromCheckpoint: number,

src/utils/blocks.ts

@@ -1,5 +1,5 @@
 import { getLatestBlock as getLatestBlockSdk, lookupBlock as lookupBlockSdk } from "@defillama/sdk/build/util";
-// import { getClient } from "../helpers/sui";
+import { getClient } from "../helpers/sui";
 import { tronGetLatestBlock } from "../helpers/tron";
 import { getConnection } from "../helpers/solana";
 import { Chain } from "@defillama/sdk/build/general";
@@ -11,6 +11,7 @@ import {
   ibcGetBlockFromTimestamp,
 } from "../adapters/ibc";
 import bridgeNetworkData from "../data/bridgeNetworkData";
+
 const retry = require("async-retry");
 
 const connection = getConnection();
@@ -21,8 +22,8 @@ async function getLatestSlot() {
 
 export async function getLatestBlockNumber(chain: string, bridge?: string): Promise<number> {
   if (chain === "sui") {
-    // const client = getClient();
-    // return Number(await client.getLatestCheckpointSequenceNumber());
+    const client = getClient();
+    return Number(await client.getLatestCheckpointSequenceNumber());
   } else if (chain === "solana") {
     return await getLatestSlot();
   } else if (chain === "tron") {
@@ -65,10 +66,10 @@ async function getBlockTime(slotNumber: number) {
 
 export async function getLatestBlock(chain: string, bridge?: string): Promise<{ number: number; timestamp: number }> {
   if (chain === "sui") {
-    // const client = getClient();
-    // const seqNumber = await client.getLatestCheckpointSequenceNumber();
-    // const { timestampMs } = await client.getCheckpoint({ id: seqNumber });
-    // return { number: Number(seqNumber), timestamp: Number(timestampMs) };
+    const client = getClient();
+    const seqNumber = await client.getLatestCheckpointSequenceNumber();
+    const { timestampMs } = await client.getCheckpoint({ id: seqNumber });
+    return { number: Number(seqNumber), timestamp: Math.floor(Number(timestampMs) / 1000) };
   } else if (chain === "tron") {
     return await tronGetLatestBlock();
   } else if (chain === "solana") {

src/utils/prices.ts

@@ -1,4 +1,5 @@
 import { PRICES_API } from "./constants";
+
 const axios = require("axios");
 const retry = require("async-retry");
 
@@ -29,7 +30,7 @@ const NAME_MAPPING: Record<string, string> = {
 export const getLlamaPrices = async (tokens: string[], timestamp?: number): Promise<Record<string, any>> => {
   const finalPrices: { [key: string]: any } = {};
   let remainingTokens = tokens.map((token) => {
-    const [prefix, id] = token.split(":");
+    const [prefix, id] = splitOnce(token, ":");
     const mappedPrefix = NAME_MAPPING[prefix] || prefix;
     return `${mappedPrefix}:${id}`;
   });
@@ -46,9 +47,22 @@ export const getLlamaPrices = async (tokens: string[], timestamp?: number): Prom
 
   return Object.fromEntries(
     Object.entries(finalPrices).map(([key, value]) => {
-      const [prefix, id] = key.split(":");
+      const [prefix, id] = splitOnce(key, ":");
       const originalPrefix = Object.entries(NAME_MAPPING).find(([, mappedName]) => mappedName === prefix)?.[0];
       return [`${originalPrefix || prefix}:${id}`, value];
     })
   );
 };
+
+function splitOnce(input: string, separator: string): string[] {
+  const index = input.indexOf(separator);
+
+  if (index === -1) {
+    return [input];
+  }
+
+  const part1 = input.substring(0, index);
+  const part2 = input.substring(index + separator.length);
+  return [part1, part2];
+}
+

src/utils/provider.ts

@@ -1,10 +1,10 @@
-// import { getClient } from "../helpers/sui";
+import { getClient } from "../helpers/sui";
 import { getProvider as getLlamaProvider } from "@defillama/sdk";
 import { getConnection } from "../helpers/solana";
 
 export function getProvider(chain: string) {
   if (chain === "sui") {
-    // return getClient();
+    return getClient();
   } else if (chain === "solana") {
     return getConnection();
   }