@cetusprotocol/aggregator-sdk 0.0.0-experimental-20240719182939

package/src/utils/coin.spec.ts

@@ -0,0 +1,10 @@
+import { parseTurbosPoolFeeType } from "./coin"
+
+describe("Coin Utils", () => {
+  it("should fetch token infos by URL and return data", async () => {
+    const typeDate =
+      "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool::Pool<0xc91acfb75009c5ff2fd57c54f3caaee12ad1fbe997681334adc0b574fc277a07::icorgi::ICORGI, 0x2::sui::SUI, 0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::fee10000bps::FEE10000BPS>"
+    const result = parseTurbosPoolFeeType(typeDate)
+    console.log("parse turbos pool type", result)
+  })
+})

package/src/utils/coin.ts

@@ -0,0 +1,61 @@
+export function completionCoin(s: string): string {
+  const index = s.indexOf("::")
+  if (index === -1) {
+    return s
+  }
+
+  const prefix = s.substring(0, index)
+  const rest = s.substring(index)
+
+  if (!prefix.startsWith("0x")) {
+    return s
+  }
+
+  const hexStr = prefix.substring(2)
+
+  if (hexStr.length > 64) {
+    return s
+  }
+
+  const paddedHexStr = hexStr.padStart(64, "0")
+
+  return `0x${paddedHexStr}${rest}`
+}
+
+export function compareCoins(coinA: string, coinB: string): boolean {
+  coinA = completionCoin(coinA)
+  coinB = completionCoin(coinB)
+  const minLength = Math.min(coinA.length, coinB.length)
+
+  for (let i = 0; i < minLength; i++) {
+    if (coinA[i] > coinB[i]) {
+      return true
+    } else if (coinA[i] < coinB[i]) {
+      return false
+    }
+  }
+
+  // If both strings are the same length and all characters are equal
+  return true // or coinB, they are equal
+}
+
+export function parseTurbosPoolFeeType(typeData: string) {
+  // "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool::Pool<0xc91acfb75009c5ff2fd57c54f3caaee12ad1fbe997681334adc0b574fc277a07::icorgi::ICORGI, 0x2::sui::SUI, 0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::fee10000bps::FEE10000BPS>"
+  const regex = /,([^,>]*>)/g
+  const matches = [...typeData.matchAll(regex)]
+  if (matches.length > 0) {
+    const lastMatch = matches[matches.length - 1][1]
+    return lastMatch.substring(0, lastMatch.length - 1).trim()
+  }
+  return null
+}
+
+export function parseAftermathFeeType(typeData: string) {
+  // 0xefe170ec0be4d762196bedecd7a065816576198a6527c99282a2551aaa7da38c::pool::Pool<0xf66c5ba62888cd0694677bbfbd2332d08ead3b8a4332c40006c474e83b1a6786::af_lp::AF_LP>
+  // get 0xf66c5ba62888cd0694677bbfbd2332d08ead3b8a4332c40006c474e83b1a6786::af_lp::AF_LP
+  const regex = /<([^>]*)>/
+  const matches = typeData.match(regex)
+  if (matches) {
+    return matches[1]
+  }
+}

package/src/utils/contracts.ts

@@ -0,0 +1,136 @@
+import { normalizeSuiObjectId } from '@mysten/sui/utils'
+import type { SuiAddress, SuiStructTag } from '../types/sui'
+import { CoinUtils, GAS_TYPE_ARG, GAS_TYPE_ARG_LONG } from '../types/CoinAssist'
+
+const EQUAL = 0
+const LESS_THAN = 1
+const GREATER_THAN = 2
+
+function cmp(a: number, b: number) {
+  if (a === b) {
+    return EQUAL
+  }
+  if (a < b) {
+    return LESS_THAN
+  }
+  return GREATER_THAN
+}
+
+function compare(symbolX: string, symbolY: string) {
+  let i = 0
+
+  const len = symbolX.length <= symbolY.length ? symbolX.length : symbolY.length
+
+  const lenCmp = cmp(symbolX.length, symbolY.length)
+  while (i < len) {
+    const elemCmp = cmp(symbolX.charCodeAt(i), symbolY.charCodeAt(i))
+    i += 1
+    if (elemCmp !== 0) {
+      return elemCmp
+    }
+  }
+
+  return lenCmp
+}
+
+export function isSortedSymbols(symbolX: string, symbolY: string) {
+  return compare(symbolX, symbolY) === LESS_THAN
+}
+
+export function composeType(address: string, generics: SuiAddress[]): SuiAddress
+export function composeType(address: string, struct: string, generics?: SuiAddress[]): SuiAddress
+export function composeType(address: string, module: string, struct: string, generics?: SuiAddress[]): SuiAddress
+export function composeType(address: string, ...args: unknown[]): SuiAddress {
+  const generics: string[] = Array.isArray(args[args.length - 1]) ? (args.pop() as string[]) : []
+  const chains = [address, ...args].filter(Boolean)
+
+  let result: string = chains.join('::')
+
+  if (generics && generics.length) {
+    result += `<${generics.join(', ')}>`
+  }
+
+  return result
+}
+
+export function extractAddressFromType(type: string) {
+  return type.split('::')[0]
+}
+
+export function extractStructTagFromType(type: string): SuiStructTag {
+  try {
+    let _type = type.replace(/\s/g, '')
+
+    const genericsString = _type.match(/(<.+>)$/)
+    const generics = genericsString?.[0]?.match(/(\w+::\w+::\w+)(?:<.*?>(?!>))?/g)
+    if (generics) {
+      _type = _type.slice(0, _type.indexOf('<'))
+      const tag = extractStructTagFromType(_type)
+      const structTag: SuiStructTag = {
+        ...tag,
+        type_arguments: generics.map((item) => extractStructTagFromType(item).source_address),
+      }
+      structTag.type_arguments = structTag.type_arguments.map((item) => {
+        return CoinUtils.isSuiCoin(item) ? item : extractStructTagFromType(item).source_address
+      })
+      structTag.source_address = composeType(structTag.full_address, structTag.type_arguments)
+      return structTag
+    }
+    const parts = _type.split('::')
+
+    const isSuiCoin = _type === GAS_TYPE_ARG || _type === GAS_TYPE_ARG_LONG
+
+    const structTag: SuiStructTag = {
+      full_address: _type,
+      address: isSuiCoin ? '0x2' : normalizeSuiObjectId(parts[0]),
+      module: parts[1],
+      name: parts[2],
+      type_arguments: [],
+      source_address: '',
+    }
+    structTag.full_address = `${structTag.address}::${structTag.module}::${structTag.name}`
+    structTag.source_address = composeType(structTag.full_address, structTag.type_arguments)
+    return structTag
+  } catch (error) {
+    return {
+      full_address: type,
+      address: '',
+      module: '',
+      name: '',
+      type_arguments: [],
+      source_address: type,
+    }
+  }
+}
+
+export function normalizeCoinType(coinType: string): string {
+  return extractStructTagFromType(coinType).source_address
+}
+
+export function fixSuiObjectId(value: string): string {
+  if (value.toLowerCase().startsWith('0x')) {
+    return normalizeSuiObjectId(value)
+  }
+  return value
+}
+
+/**
+ * Recursively traverses the given data object and patches any string values that represent Sui object IDs.
+ *
+ * @param {any} data - The data object to be patched.
+ */
+export function patchFixSuiObjectId(data: any) {
+  for (const key in data) {
+    const type = typeof data[key]
+    if (type === 'object') {
+      patchFixSuiObjectId(data[key])
+    } else if (type === 'string') {
+      const value = data[key]
+      data[key] = fixSuiObjectId(value)
+    }
+  }
+}
+
+export function createTarget(packageName: string, moduleName: string, functionName: string): `${string}::${string}::${string}` {
+  return `${packageName}::${moduleName}::${functionName}`
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './contracts'

package/src/utils/transaction.ts

@@ -0,0 +1,20 @@
+import { Transaction } from "@mysten/sui/transactions"
+
+export async function printTransaction(tx: Transaction, isPrint = true) {
+  console.log(`inputs`, tx.getData().inputs)
+  let i = 0
+
+  tx.getData().commands.forEach((item, index) => {
+    if (isPrint && i < 15) {
+      console.log(`transaction ${index}: `, JSON.stringify(item, null, 2))
+      i++
+    }
+  })
+}
+
+export function checkInvalidSuiAddress(address: string): boolean {
+  if (!address.startsWith("0x") || address.length !== 66) {
+    return false
+  }
+  return true
+}

package/tests/router.test.ts

@@ -0,0 +1,255 @@
+import { describe, expect, test } from "@jest/globals"
+import dotenv from "dotenv"
+import { AggregatorClient } from "~/client"
+import { AggregatorConfig, ENV } from "~/config"
+import {
+  M_CETUS,
+  M_HASUI,
+  M_NAVI,
+  M_SUI,
+  M_USDC,
+  M_VAPOR,
+  M_VSUI,
+} from "../src/test_data.test"
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"
+import { printTransaction } from "~/utils/transaction"
+import BN from "bn.js"
+import { fromHEX } from "@mysten/bcs"
+
+dotenv.config()
+
+export function buildTestAccount(): Ed25519Keypair {
+  const mnemonics = process.env.SUI_WALLET_MNEMONICS || ""
+  const testAccountObject = Ed25519Keypair.deriveKeypair(mnemonics)
+  return testAccountObject
+}
+
+describe("router module", () => {
+  let config: AggregatorConfig
+  let client: AggregatorClient
+  let keypair: Ed25519Keypair
+
+  beforeAll(() => {
+    const fullNodeURL = process.env.SUI_RPC!
+    const aggregatorURL = process.env.CETUS_AGGREGATOR!
+    const secret = process.env.SUI_WALLET_SECRET!
+
+    // const byte = Buffer.from(secret, "hex")
+    const byte = Buffer.from(secret, "base64")
+    const u8Array = new Uint8Array(byte)
+    // keypair = secret
+    //   ? Ed25519Keypair.fromSecretKey(u8Array.slice(1, 33))
+    //   : buildTestAccount()
+
+    keypair = Ed25519Keypair.fromSecretKey(fromHEX(secret))
+
+    const wallet = keypair.getPublicKey().toSuiAddress()
+    console.log("wallet", wallet)
+    // const wallet =
+    // "0x1d30e55c730f92a02a33dbdf6b052cd178e5d924aa58c5e2350a24852250ae58"
+    // const wallet = "0xaabf2fedcb36146db164bec930b74a47969c4df98216e049342a3c49b6d11580"
+    // const wallet = "0x410456cfc689666936b6bf80fbec958b69499b9f7183ecba07de577c17248a44"
+    // const wallet = "0xca171941521153181ff729d53489eaae7e99c3f4692884afd7cca61154e4cec4"
+    // console.log("wallet: ", wallet)
+
+    const aggregatorPackage = {
+      packageName: "aggregator",
+      packageId:
+        "0x640d44dbdc0ede165c7cc417d7f57f1b09648083109de7132c6b3fb15861f5ee",
+      publishedAt:
+        "0x640d44dbdc0ede165c7cc417d7f57f1b09648083109de7132c6b3fb15861f5ee",
+    }
+
+    const integratePackage = {
+      packageName: "integrate",
+      packageId:
+        "0x996c4d9480708fb8b92aa7acf819fb0497b5ec8e65ba06601cae2fb6db3312c3",
+      publishedAt:
+        "0x8faab90228e4c4df91c41626bbaefa19fc25c514405ac64de54578dec9e6f5ee",
+    }
+
+    config = new AggregatorConfig(
+      aggregatorURL,
+      fullNodeURL,
+      wallet,
+      [aggregatorPackage, integratePackage],
+      ENV.MAINNET
+    )
+    client = new AggregatorClient(config)
+  })
+
+  test("Init aggregator client", () => {
+    expect(config.getAggregatorUrl().length > 0).toBe(true)
+    expect(config.getWallet().length > 0).toBe(true)
+  })
+
+  test("Get all coins", () => {
+    return client.getAllCoins().then((coins) => {
+      console.log(coins)
+    })
+  })
+
+  test("Downgrade swap in route", async () => {
+    const amount = 1000000
+
+    const res = await client.swapInPools({
+      from: M_NAVI,
+      target: M_SUI,
+      amount: new BN(amount),
+      byAmountIn: false,
+      pools: [
+        "0x0254747f5ca059a1972cd7f6016485d51392a3fde608107b93bbaebea550f703",
+      ],
+    })
+
+    if (res != null) {
+      console.log(JSON.stringify(res, null, 2))
+    }
+  })
+
+  test("Find router", async () => {
+    const amount = "10000000000000000"
+
+    const res = await client.findRouter({
+      from: M_SUI,
+      target: M_USDC,
+      amount: new BN(amount),
+      byAmountIn: true,
+      depth: 1,
+      splitAlgorithm: null,
+      splitFactor: null,
+      splitCount: 1,
+      providers: [
+        // "AFTERMATH",
+        // "CETUS",
+        "DEEPBOOK",
+        // "KRIYA",
+        // "FLOWX",
+        // "AFTERMATH",
+        // "TRUBOS",
+      ],
+    })
+
+    if (res != null) {
+      console.log(JSON.stringify(res, null, 2))
+    }
+
+    console.log("amount in", res?.amountIn.toString())
+    console.log("amount out", res?.amountOut.toString())
+  })
+
+  test("Build router tx", async () => {
+    const byAmountIn = true
+    const amount = 500000000
+
+    const from = M_SUI
+    const target = M_NAVI
+
+    const res = await client.findRouter({
+      from,
+      target,
+      amount: new BN(amount),
+      byAmountIn,
+      depth: 3,
+      splitAlgorithm: null,
+      splitFactor: null,
+      splitCount: null,
+      providers: ["CETUS", "DEEPBOOK", "KRIYA", "FLOWX", "AFTERMATH", "TURBOS"],
+    })
+
+    if (res != null) {
+      console.log(JSON.stringify(res, null, 2))
+    }
+
+    console.log("amount in", res?.amountIn.toString())
+    console.log("amount out", res?.amountOut.toString())
+
+    if (res != null) {
+      console.log(JSON.stringify(res, null, 2))
+      const routerTx = await client.routerSwap({
+        routers: res.routes,
+        amountIn: res.amountIn,
+        amountOut: res.amountOut,
+        byAmountIn,
+        slippage: 0.01,
+        fromCoinType: from,
+        targetCoinType: target,
+        partner: undefined,
+        isMergeTragetCoin: true,
+      })
+
+      printTransaction(routerTx)
+
+      let result = await client.devInspectTransactionBlock(routerTx, keypair)
+
+      if (result.effects.status.status === "success") {
+        console.log("Sim exec transaction success")
+        // const result = await client.signAndExecuteTransaction(routerTx, keypair)
+        // console.log("result", result)
+      } else {
+        console.log("result", result)
+      }
+    }
+  }, 600000)
+
+  test("Test Multi Input", async () => {
+    const amounts = [1000000000, 2000000000, 10000000000000]
+    const froms = [M_USDC, M_SUI, M_CETUS, M_NAVI]
+    const tos = [M_SUI, M_USDC, M_USDC, M_SUI]
+
+    for (let i = 0; i < froms.length; i++) {
+      const from = froms[i]
+      const target = tos[i]
+      for (const amount of amounts) {
+        for (const byAmountIn of [true, false]) {
+          console.log({
+            from,
+            target,
+            amount,
+            byAmountIn,
+          })
+          const res = await client.findRouter({
+            from,
+            target,
+            amount: new BN(amount),
+            byAmountIn,
+            depth: null,
+            splitAlgorithm: null,
+            splitFactor: null,
+            splitCount: null,
+            providers: null,
+          })
+
+          if (res != null) {
+            const routerTx = await client.routerSwap({
+              routers: res.routes,
+              amountIn: res.amountIn,
+              amountOut: res.amountOut,
+              byAmountIn,
+              slippage: 0.01,
+              fromCoinType: from,
+              targetCoinType: target,
+              partner: undefined,
+              isMergeTragetCoin: false,
+            })
+
+            let result = await client.devInspectTransactionBlock(
+              routerTx,
+              keypair
+            )
+            // console.log('result', result)
+
+            if (result.effects.status.status === "success") {
+              console.log("Sim exec transaction success")
+              // const result = await client.signAndExecuteTransaction(routerTx, keypair)
+              // console.log('result', result)
+            } else {
+              console.log("Sim exec transaction failed")
+              // console.log('result', result)
+            }
+          }
+        }
+      }
+    }
+  }, 60000000)
+})

package/tests/wallet.test.ts

@@ -0,0 +1,21 @@
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519"
+
+describe("router module", () => {
+  const keystoreSecret = [
+    "0xd36441c734b1967dd4e65956d0b3e7e5dccc8c92306ad71419e6741b4a7ce6c9",
+  ]
+
+  test("Parse public key", () => {
+    for (const secret of keystoreSecret) {
+      const byte = Buffer.from(secret, "base64")
+      const u8Array = new Uint8Array(byte)
+      const keypair = Ed25519Keypair.fromSecretKey(u8Array.slice(1, 33))
+      console.log(
+        "\nsecret:",
+        secret,
+        "\nkeypair public key: ",
+        keypair.toSuiAddress()
+      )
+    }
+  })
+})

package/tsconfig.json

@@ -0,0 +1,22 @@
+// tsconfig.json
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": "./",
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["src/*"]
+    },
+    "allowJs": true,
+    "outDir": "dist/",
+  },
+  "include": ["src", "tests"],
+  "exclude": [
+    "node_modules/**/*",
+    "dist/**/*",
+  ],
+}

package/tsup.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from 'tsup'
+import { exec } from 'child_process'
+
+export default defineConfig((options) => ({
+    entry: {
+        index: './src/index.ts',
+    },
+    format: ['esm', 'cjs'],
+    dts: false,
+    clean: !options.watch,
+    treeshake: true,
+    splitting: true,
+    onSuccess: async () => {
+        exec('tsc --emitDeclarationOnly --declaration', (err, stdout) => {
+            if (err) {
+                console.error(stdout)
+                if (!options.watch) {
+                    process.exit(1)
+                }
+            }
+        })
+    },
+}))

package/version.mjs

@@ -0,0 +1,28 @@
+// Don't sync to github
+
+import fs from 'fs';
+
+const packageJsonPath = './package.json';
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+const newVersion = `0.0.0-experimental-${getCurrentDateTimeString()}`;
+packageJson.version = newVersion;
+
+fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+
+console.log(`Version updated to ${newVersion}`);
+
+function getCurrentDateTimeString() {
+  const now = new Date();
+
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+
+  const dateTimeString = `${year}${month}${day}${hours}${minutes}${seconds}`;
+
+  return dateTimeString;
+}