@mmt-finance/amm-sui-sdk 0.0.1-beta

package/src/utils/constants.ts

@@ -0,0 +1,150 @@
+export class DexConstants {
+  // Legacy constants for backward compat if needed, but we will mostly use NETWORK_CONFIG
+  public static readonly packageId =
+    '0xcf1fc98b09bc29b7747412ca3bbf36e63f0f213a485db7fe19c8500d4b3d9bab';
+  public static readonly packageIdV1 =
+    '0xcf1fc98b09bc29b7747412ca3bbf36e63f0f213a485db7fe19c8500d4b3d9bab';
+  public static readonly farmPackageId =
+    '0x88701243d0445aa38c0a13f02a9af49a58092dfadb93af9754edb41c52f40085';
+  public static readonly suiPackageId =
+    '0x0000000000000000000000000000000000000000000000000000000000000002';
+
+  public static readonly suiCoinType =
+    '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+
+  public static readonly functions = {
+    swapX: 'swap_token_x',
+    swapY: 'swap_token_y',
+    createPool: 'create_pool_',
+    createPoolInternal: 'create_pool',
+    createPoolAndAddLiquidity: 'create_pool_and_add_liquidity',
+    addLiquidityInternal: 'add_liquidity',
+  };
+}
+
+export const NETWORK_CONFIG = {
+  mainnet: {
+    packageId: '0xcf1fc98b09bc29b7747412ca3bbf36e63f0f213a485db7fe19c8500d4b3d9bab',
+    packageIdV1: '0xcf1fc98b09bc29b7747412ca3bbf36e63f0f213a485db7fe19c8500d4b3d9bab',
+    farmPackageId: '0x88701243d0445aa38c0a13f02a9af49a58092dfadb93af9754edb41c52f40085',
+    protocolConfigs: '0x...', // TODO: Add Mainnet ProtocolConfigs ID
+  },
+  testnet: {
+    packageId: '0xaee0193a13a2ff9e4d20360789aa9132a3a97cd1d92e641c96f28a07e97c7375',
+    packageIdV1: '0xaee0193a13a2ff9e4d20360789aa9132a3a97cd1d92e641c96f28a07e97c7375', // TODO: What's this? Do we really need it?
+    farmPackageId: '0x88701243d0445aa38c0a13f02a9af49a58092dfadb93af9754edb41c52f40085', // TODO: What's this? Do we really need it?
+    protocolConfigs: '0xc0e50d862bc57afc72edac15cde58e8f8cc3ed2517d8521dfb295f8d083c5a47',
+  },
+};
+
+export const TEMP_POOL_DATA: Record<
+  string,
+  {
+    upsaclingFactor: number;
+    baseToken: string;
+    amountUpscalingFactor: number;
+    tickSize: number;
+    minAmount: number;
+    lotSize: number;
+  }
+> = {
+  //V2 pools
+  '0xc0833efe1d86978ebf57a3ce4a41b2c2b9e20faf802305f1eda306c8fc64ee40': {
+    upsaclingFactor: 1e13,
+    amountUpscalingFactor: 1e5,
+    baseToken: 'FUD',
+    tickSize: 100,
+    minAmount: 100,
+    lotSize: 100000000000,
+  },
+  '0x4405b50d791fd3346754e8171aaab6bc2ed26c2c46efdd033c14b30ae507ac33': {
+    upsaclingFactor: 1e6,
+    amountUpscalingFactor: 1e9,
+    baseToken: 'SUI',
+    tickSize: 100,
+    minAmount: 0.1,
+    lotSize: 100000000,
+  },
+  '0x6e417ee1c12ad5f2600a66bc80c7bd52ff3cb7c072d508700d17cf1325324527': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WETH',
+    amountUpscalingFactor: 1e8,
+    tickSize: 1000000,
+    minAmount: 0.0001,
+    lotSize: 10000,
+  },
+  '0x31d1790e617eef7f516555124155b28d663e5c600317c769a75ee6336a54c07f': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WBTC',
+    tickSize: 1000000,
+    minAmount: 0.00001,
+    lotSize: 1000,
+    amountUpscalingFactor: 1e8,
+  },
+  '0xd1f0a9baacc1864ab19534e2d4c5d6c14f2e071a1f075e8e7f9d51f2c17dc238': {
+    upsaclingFactor: 1e9,
+    baseToken: 'USDT',
+    tickSize: 100000,
+    minAmount: 0.1,
+    lotSize: 100000,
+    amountUpscalingFactor: 1e6,
+  },
+  //v1 pools
+  '0x7f526b1263c4b91b43c9e646419b5696f424de28dda3c1e6658cc0a54558baa7': {
+    upsaclingFactor: 1e6,
+    amountUpscalingFactor: 1e9,
+    baseToken: 'SUI',
+    tickSize: 100,
+    minAmount: 0.1,
+    lotSize: 100000000,
+  },
+  '0xd9e45ab5440d61cc52e3b2bd915cdd643146f7593d587c715bc7bfa48311d826': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WETH',
+    amountUpscalingFactor: 1e8,
+    tickSize: 1000000,
+    minAmount: 0.0001,
+    lotSize: 10000,
+  },
+  '0xf0f663cf87f1eb124da2fc9be813e0ce262146f3df60bc2052d738eb41a25899': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WBTC',
+    tickSize: 1000000,
+    minAmount: 0.00001,
+    lotSize: 1000,
+    amountUpscalingFactor: 1e8,
+  },
+  '0x5deafda22b6b86127ea4299503362638bea0ca33bb212ea3a67b029356b8b955': {
+    upsaclingFactor: 1e9,
+    baseToken: 'USDC',
+    tickSize: 100000,
+    minAmount: 0.1,
+    lotSize: 100000,
+    amountUpscalingFactor: 1e6,
+  },
+  // testnet pools
+  '0xb288337ce29aff7fbce8827ba16e74f0f4c1c0b312873464bd220f2eb771edc6': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WBTC',
+    tickSize: 1000000,
+    minAmount: 0.00001,
+    lotSize: 1000,
+    amountUpscalingFactor: 1e6,
+  },
+  '0x715a62958fba1e7c8d61d849fdd0b60c734a24a6e78fbefd8049b0f7e41b7204': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WBTC',
+    tickSize: 1000000,
+    minAmount: 0.00001,
+    lotSize: 1000,
+    amountUpscalingFactor: 1e8,
+  },
+  '0x22b276b1f0e2dca4e7483f7da035e7f99d8831aa9cbec131058b6bb5768f998d': {
+    upsaclingFactor: 1e7,
+    baseToken: 'WBTC',
+    tickSize: 1000000,
+    minAmount: 0.00001,
+    lotSize: 1000,
+    amountUpscalingFactor: 1e8,
+  },
+};

package/src/utils/types.ts

@@ -0,0 +1,155 @@
+import { Transaction, TransactionArgument } from '@mysten/sui/transactions';
+
+export interface Pool {
+  objectId: string;
+  tokenXType: string;
+  tokenYType: string;
+  isStable?: boolean;
+}
+
+export interface Farm {
+  objectId: string;
+  tokenXType: string;
+  tokenYType: string;
+}
+
+export interface GetExactCoinByAmountOptions {
+  coinType: string;
+  coins: { objectId: string; balance: bigint }[];
+  amount: bigint;
+  txb: Transaction;
+}
+
+export interface SwapOptions {
+  pool: Pool;
+  inputCoinType: string;
+  inputCoinAmount: bigint | TransactionArgument;
+  inputCoin: string | TransactionArgument;
+  minReceived: bigint;
+  txb: Transaction;
+  transferToAddress?: string;
+}
+
+export interface SwapWithRouteOptions {
+  pools: Pool[];
+  inputCoinType: string;
+  inputCoinAmount: bigint | TransactionArgument;
+  inputCoin: string | TransactionArgument;
+  minReceived: bigint;
+  txb: Transaction;
+  transferToAddress?: string;
+}
+
+export interface RemoveLiquidityOptions {
+  pool: Pool;
+  amount: bigint | TransactionArgument;
+  mmtLpToken: string | TransactionArgument;
+  txb: Transaction;
+  transferToAddress?: string;
+}
+
+export interface AddLiquidityOptions {
+  pool: Pool;
+  amountX: bigint | TransactionArgument;
+  amountY: bigint | TransactionArgument;
+  minAddAmountX: bigint;
+  minAddAmountY: bigint;
+  coinX: string | TransactionArgument;
+  coinY: string | TransactionArgument;
+  txb: Transaction;
+  transferToAddress?: string;
+}
+
+export interface AddLiquiditySingleSidedOptions {
+  pool: Pool;
+  inputCoinType: string;
+  inputCoinAmount: bigint;
+  inputCoin: string | TransactionArgument;
+  tokenInDecimals: number;
+  tokenOutDecimals: number;
+  swapSlippageTolerance: number;
+  txb: Transaction;
+  transferToAddress?: string;
+}
+
+export interface GetUserLpPositionsOptions {
+  pool: Pool;
+  userAddress: string;
+  maxIter?: number;
+  cursor?: string | null;
+}
+
+export interface GetSwapAmountStableOptions {
+  reserveA: bigint;
+  reserveB: bigint;
+  scaleA: bigint;
+  scaleB: bigint;
+  amount: bigint;
+  totalFeeRate?: bigint;
+}
+
+export interface GetSwapAmountUncorrelatedOptions {
+  reserveA: bigint;
+  reserveB: bigint;
+  amount: bigint;
+  totalFeeRate?: bigint;
+}
+
+export interface GetLpAmountInOptions {
+  amountX: bigint;
+  amountY: bigint;
+  lspSupply: bigint;
+  reserveX: bigint;
+  reserveY: bigint;
+}
+
+export interface GetLpAmountOutOptions {
+  lspAmount: bigint;
+  lspSupply: bigint;
+  reserveX: bigint;
+  reserveY: bigint;
+}
+
+export interface MergeLpsTxOptions {
+  txb: Transaction;
+  lps: string[];
+  typeX: string;
+  typeY: string;
+}
+
+export interface SplitLpsTxOptions {
+  txb: Transaction;
+  lp: string | TransactionArgument;
+  amount: number;
+  typeX: string;
+  typeY: string;
+}
+
+export interface CreatePoolOptions {
+  isStable: boolean;
+  decimalsX: number;
+  decimalsY: number;
+  txb: Transaction;
+  typeX: string;
+  typeY: string;
+}
+
+export interface CreatePoolAndAddLiquidityOptions {
+  isStable: boolean;
+  decimalsX: number;
+  decimalsY: number;
+  txb: Transaction;
+  typeX: string;
+  typeY: string;
+  minAddAmountX: bigint;
+  minAddAmountY: bigint;
+  coinX: string | TransactionArgument;
+  coinY: string | TransactionArgument;
+}
+
+export type Network = 'mainnet' | 'testnet';
+
+export interface SdkOptions {
+  network?: Network;
+  rpcEndpoint: string;
+}

package/src/utils/utils.ts

@@ -0,0 +1,308 @@
+import { SuiClient } from "@mysten/sui/client";
+import axios from "axios";
+
+const FEE_SCALING = BigInt(1000000);
+/// We take 10^8 as we expect most of the coins to have 6-8 decimals.
+const ONE_E_8 = BigInt(100000000);
+
+const coingeckoID = (ticker: string) => {
+  switch (ticker) {
+    case "SUI":
+      return "sui";
+    case "USDC":
+    case "USDCeth":
+    case "USDCbnb":
+      return "usd-coin";
+    case "WETH":
+      return "ethereum";
+    case "SPEPE":
+      return "suipepe";
+    case "MOVE":
+      return "bluemove";
+    case "USDT":
+      return "tether";
+    case "WBTC":
+    case "BTC":
+      return "bitcoin";
+    default:
+      return "";
+  }
+};
+
+/// Get output price for uncorrelated curve x*y = k
+const getPriceUncorrelated = (
+  input_amount: bigint,
+  input_reserve: bigint,
+  output_reserve: bigint,
+  fee_percent: bigint,
+) => {
+  let input_amount_with_fee = input_amount * (FEE_SCALING - fee_percent);
+  let numerator = input_amount_with_fee * output_reserve;
+  let denominator = input_reserve * FEE_SCALING + input_amount_with_fee;
+
+  return numerator / denominator;
+};
+
+const getPriceStable = (
+  input_amount: bigint,
+  input_reserve: bigint,
+  output_reserve: bigint,
+  fee_percent: bigint,
+  input_scale: bigint,
+  output_scale: bigint,
+) => {
+  let u2561e8 = ONE_E_8;
+
+  let xy = lp_value(input_reserve, input_scale, output_reserve, output_scale);
+
+  let reserve_in_u256 = (input_reserve * u2561e8) / input_scale;
+  let reserve_out_u256 = (output_reserve * u2561e8) / output_scale;
+  let amount_in = (input_amount * u2561e8) / input_scale;
+  let amount_in_with_fees_scaling =
+    (amount_in * (FEE_SCALING - fee_percent)) / FEE_SCALING;
+  let total_reserve = amount_in_with_fees_scaling + reserve_in_u256;
+  let y = reserve_out_u256 - get_y(total_reserve, xy, reserve_out_u256);
+
+  let r = (y * output_scale) / u2561e8;
+
+  return r;
+};
+
+/// Get LP value for stable curve: x^3*y + x*y^3
+/// * `x_coin` - reserves of coin X.
+/// * `x_scale` - 10 pow X coin decimals amount.
+/// * `y_coin` - reserves of coin Y.
+/// * `y_scale` - 10 pow Y coin decimals amount.
+const lp_value = (
+  x_coin: bigint,
+  x_scale: bigint,
+  y_coin: bigint,
+  y_scale: bigint,
+) => {
+  let _x = (x_coin * ONE_E_8) / x_scale;
+  let _y = (y_coin * ONE_E_8) / y_scale;
+
+  let xy = _x * _y;
+  let x2_y2 = _x * _x + _y * _y;
+
+  return xy * x2_y2;
+};
+
+/// get value of reserve_y - output_y
+/// * `x0` = reserve_x + input_x = total x reserve after adding input
+/// * `xy` - original value of x^3*y + x*y^3
+/// * `y` - reserve_y - initial guess is reserve_y
+/// calculate 255 iterations of Newton's method for x^3*y + x*y^3
+const get_y = (x0: bigint, xy: bigint, y: bigint) => {
+  let i = 0;
+
+  let one_u256 = BigInt(1);
+
+  while (i < 255) {
+    let k = f(x0, y);
+
+    let _dy = BigInt(0);
+    if (xy > k) {
+      _dy = (xy - k) / d(x0, y) + one_u256; // Round up
+      y = y + _dy;
+    } else {
+      _dy = (k - xy) / d(x0, y) + one_u256;
+      y = y - _dy;
+    }
+    if (_dy <= one_u256) {
+      return y;
+    }
+
+    i = i + 1;
+  }
+
+  return y;
+};
+
+/// Implements x0*y^3 + x0^3*y = x0*(y*y/1e18*y/1e18)/1e18+(x0*x0/1e18*x0/1e18)*y/1e18
+const f = (x0_u256: bigint, y_u256: bigint) => {
+  // x0*(y*y/1e18*y/1e18)/1e18
+  let yy = y_u256 * y_u256;
+  let yyy = yy * y_u256;
+
+  let a = x0_u256 * yyy;
+
+  //(x0*x0/1e18*x0/1e18)*y/1e18
+  let xx = x0_u256 * x0_u256;
+  let xxx = xx * x0_u256;
+  let b = xxx * y_u256;
+
+  // a + b
+  return a + b;
+};
+
+/// Implements 3 * x0 * y^2 + x0^3 = 3 * x0 * (y * y / 1e8) / 1e8 + (x0 * x0 / 1e8 * x0) / 1e8
+const d = (x0_u256: bigint, y_u256: bigint) => {
+  let three_u256 = BigInt(3);
+
+  // 3 * x0 * (y * y / 1e8) / 1e8
+  let x3 = three_u256 * x0_u256;
+  let yy = y_u256 * y_u256;
+  let xyy3 = x3 * yy;
+  let xx = x0_u256 * x0_u256;
+
+  // x0 * x0 / 1e8 * x0 / 1e8
+  let xxx = xx * x0_u256;
+
+  return xyy3 + xxx;
+};
+
+const bigIntMax = (args: bigint[]) => args.reduce((m, e) => (e > m ? e : m));
+const bigIntMin = (args: bigint[]) => args.reduce((m, e) => (e < m ? e : m));
+
+const queryAllUserEvents = async (address: string, provider: SuiClient) => {
+  let cursor: { txDigest: string; eventSeq: string } | null | undefined = null;
+  let data: any[] = [];
+  let iter = 0;
+  do {
+    try {
+      const res: any = await provider.queryEvents({
+        query: {
+          Sender: address,
+        },
+        limit: 100,
+        cursor: cursor as { txDigest: string; eventSeq: string } | null,
+      });
+      data = [...data, ...res.data];
+      cursor = res.nextCursor;
+      if (!res.hasNextPage) {
+        cursor = null;
+      }
+    } catch (error) {
+      console.log(error);
+      cursor = null;
+    }
+    iter++;
+  } while (cursor !== null && iter < 2);
+  return data;
+};
+
+const fetchTokenDataCoingecko = async (ticker: string) => {
+  try {
+    const coingeckoId = coingeckoID(ticker);
+    if (coingeckoId !== "") {
+      const response = await axios.get(
+        `https://api.coingecko.com/api/v3/coins/${coingeckoId}`,
+      );
+      const jsonData = response.data;
+      return {
+        price: jsonData.market_data["current_price"]["usd"] as number,
+        high24: jsonData.market_data["high_24h"]["usd"] as number,
+        low24: jsonData.market_data["low_24h"]["usd"] as number,
+        change: jsonData.market_data["price_change_percentage_24h"] as number,
+      };
+    }
+  } catch (e) {
+    console.log(e);
+  }
+};
+
+const babylonianSqrt = (y: number): number => {
+  let x: number, z: number;
+  if (y > 3) {
+    z = y;
+    x = y / 2 + 1;
+    while (x < z) {
+      z = x;
+      x = (y / x + x) / 2;
+    }
+    return z;
+  } else if (y != 0) {
+    z = 1;
+    return z;
+  }
+  return 0;
+};
+const calculateStableSwapAmount = (
+  totalAmount: number,
+  tokenXReserve: number,
+  tokenYReserve: number,
+  isX: boolean,
+): number => {
+  const ratio = tokenXReserve / tokenYReserve;
+  let swapAmount: number;
+
+  if (!isX) {
+    swapAmount = totalAmount / (1 + 1 / ratio);
+  } else {
+    swapAmount = totalAmount - totalAmount / (1 + 1 / ratio);
+  }
+
+  return swapAmount;
+};
+
+const getOptimalLpSwapAmount = async (
+  inputAmt: bigint,
+  poolId: string,
+  isXtoY: boolean,
+  client: SuiClient, // Changed from instantiating Dex to passing Client
+  isStable?: boolean,
+): Promise<bigint> => {
+  const txn = await client.getObject({
+    id: poolId,
+    options: { showContent: true },
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const content = txn.data?.content as any;
+  const tokenReserve = isXtoY
+    ? Number(content.fields.token_x)
+    : Number(content.fields.token_y);
+
+  if (!isStable && tokenReserve) {
+    const swapAmt =
+      (babylonianSqrt(
+        tokenReserve * (tokenReserve * 3992004 + Number(inputAmt) * 3992000),
+      ) -
+        tokenReserve * 1998) /
+      1996;
+    return BigInt(Math.round(swapAmt));
+  } else {
+    const swapAmtStable = calculateStableSwapAmount(
+      Number(inputAmt),
+      Number(content.fields.token_x),
+      Number(content.fields.token_y),
+      isXtoY,
+    );
+    return BigInt(Math.round(swapAmtStable));
+  }
+};
+
+const fetchCoinPrice = async (coinType: string) => {
+  const BIRDEYE_API_KEY = "";
+  try {
+    const response = await axios.get(
+      `https://public-api.birdeye.so/defi/price?address=${coinType.replace(
+        /^\s+/g,
+        "",
+      )}&address_type=token`,
+      {
+        headers: {
+          "x-chain": "sui",
+          "X-API-KEY": BIRDEYE_API_KEY,
+        },
+      },
+    );
+
+    return response.data.data.value;
+  } catch (err) {
+    throw new Error(`Failed to fetch price for ${coinType}`);
+  }
+};
+
+export {
+  getPriceStable,
+  coingeckoID,
+  bigIntMax,
+  bigIntMin,
+  getPriceUncorrelated,
+  queryAllUserEvents,
+  fetchTokenDataCoingecko,
+  getOptimalLpSwapAmount,
+  fetchCoinPrice,
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src", "test"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  splitting: false,
+  target: "esnext",
+  outDir: "dist",
+});