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

package/commitlint.config.js

@@ -0,0 +1,3 @@
+export default {
+  extends: ["@commitlint/config-conventional"],
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mmt-finance/amm-sui-sdk",
+  "version": "0.0.1-beta",
+  "type": "module",
+  "description": "Momentum SDK to access the Momentum AMM DeFi protocols suite on Sui.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "bun run build",
+    "test": "vitest",
+    "lint": "eslint src",
+    "format": "prettier --write \"src/**/*.{ts,js,json,md}\"",
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "@mysten/sui": "^1.3.0",
+    "axios": "^1.4.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^18.4.3",
+    "@commitlint/config-conventional": "^18.4.3",
+    "@types/node": "^20.14.11",
+    "bun-types": "latest",
+    "eslint": "^8.56.0",
+    "husky": "^8.0.3",
+    "prettier": "^3.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.5.3",
+    "vitest": "^1.2.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import { Dex } from './sdk/dex';
+
+export * from './utils/types';
+export * from './utils/constants';
+export * from './utils/utils';
+
+export { Dex as MmtAmmSdk };

package/src/sdk/dex.ts

@@ -0,0 +1,423 @@
+import { TransactionArgument, TransactionObjectArgument } from '@mysten/sui/transactions';
+import { DexConstants } from '../utils/constants';
+import { SdkBase } from './sdkBase';
+import {
+  Pool,
+  SwapOptions,
+  SwapWithRouteOptions,
+  RemoveLiquidityOptions,
+  AddLiquidityOptions,
+  AddLiquiditySingleSidedOptions,
+  GetUserLpPositionsOptions,
+  GetSwapAmountStableOptions,
+  GetSwapAmountUncorrelatedOptions,
+  GetLpAmountInOptions,
+  GetLpAmountOutOptions,
+  MergeLpsTxOptions,
+  SplitLpsTxOptions,
+  CreatePoolOptions,
+  CreatePoolAndAddLiquidityOptions,
+  SdkOptions,
+} from '../utils/types';
+import {
+  bigIntMin,
+  fetchCoinPrice,
+  getOptimalLpSwapAmount,
+  getPriceStable,
+  getPriceUncorrelated,
+} from '../utils/utils';
+
+export class Dex extends SdkBase {
+  constructor(options: SdkOptions | string) {
+    super(options);
+  }
+
+  public createPool({
+    isStable,
+    decimalsX,
+    decimalsY,
+    txb,
+    typeX,
+    typeY,
+  }: CreatePoolOptions): void {
+    txb.moveCall({
+      target: `${this.config.packageId}::spot_dex::${DexConstants.functions.createPool}`,
+      arguments: [
+        txb.object(this.config.protocolConfigs),
+        txb.pure.bool(isStable),
+        txb.pure.u8(decimalsX),
+        txb.pure.u8(decimalsY),
+      ],
+      typeArguments: [typeX, typeY],
+    });
+  }
+
+  public createPoolAndAddLiquidity({
+    isStable,
+    decimalsX,
+    decimalsY,
+    txb,
+    typeX,
+    typeY,
+    minAddAmountX,
+    minAddAmountY,
+    coinX,
+    coinY,
+  }: CreatePoolAndAddLiquidityOptions) {
+    const coinXObject = typeof coinX === 'string' ? txb.object(coinX) : coinX;
+    const coinYObject = typeof coinY === 'string' ? txb.object(coinY) : coinY;
+
+    txb.moveCall({
+      target: `${this.config.packageId}::spot_dex::${DexConstants.functions.createPoolAndAddLiquidity}`,
+      arguments: [
+        txb.object(this.config.protocolConfigs),
+        txb.pure.bool(isStable),
+        txb.pure.u8(decimalsX),
+        txb.pure.u8(decimalsY),
+        coinYObject,
+        coinXObject,
+        txb.pure.u64(minAddAmountY),
+        txb.pure.u64(minAddAmountX),
+      ],
+      typeArguments: [typeX, typeY],
+    });
+  }
+
+  public swap({
+    pool,
+    inputCoinType,
+    inputCoinAmount,
+    inputCoin,
+    minReceived,
+    txb,
+    transferToAddress,
+  }: SwapOptions): TransactionArgument | undefined {
+    const isXtoY = pool.tokenXType === inputCoinType;
+    const inputCoinObject = typeof inputCoin === 'string' ? txb.object(inputCoin) : inputCoin;
+    const inputTokenAmount =
+      typeof inputCoinAmount === 'bigint' ? txb.pure.u64(inputCoinAmount) : inputCoinAmount;
+
+    const txnResult = txb.moveCall({
+      target: `${this.config.packageId}::spot_dex::${isXtoY ? DexConstants.functions.swapX : DexConstants.functions.swapY}`,
+      arguments: [
+        txb.object(pool.objectId),
+        inputCoinObject,
+        inputTokenAmount,
+        txb.pure.u64(minReceived),
+      ],
+      typeArguments: [pool.tokenXType, pool.tokenYType],
+    });
+
+    if (Boolean(transferToAddress)) {
+      txb.transferObjects([txnResult], txb.pure.address(transferToAddress!));
+    } else {
+      return txnResult;
+    }
+  }
+
+  public swapWithRoute({
+    pools,
+    inputCoinType,
+    inputCoinAmount,
+    inputCoin,
+    minReceived,
+    txb,
+    transferToAddress,
+  }: SwapWithRouteOptions): TransactionArgument | undefined {
+    let inputTokenType = inputCoinType;
+    let inputToken = inputCoin;
+    let inputTokenAmount = inputCoinAmount;
+    let txbResultToReturn;
+    pools.forEach((pool: Pool, idx) => {
+      const isXtoY = pool.tokenXType === inputTokenType;
+      const txRes = this.swap({
+        pool,
+        inputCoinType: inputTokenType,
+        inputCoinAmount: inputTokenAmount,
+        inputCoin: inputToken,
+        minReceived: idx == pools.length - 1 ? minReceived : BigInt(0), // set with zero for non last pools.
+        txb,
+      });
+
+      if (!txRes) {
+        throw new Error('Swap failed during route execution');
+      }
+
+      inputTokenType = isXtoY ? pool.tokenYType : pool.tokenXType;
+      inputToken = txRes;
+      inputTokenAmount = this.getCoinValue(inputTokenType, inputToken, txb);
+      txbResultToReturn = txRes;
+    });
+
+    if (Boolean(transferToAddress)) {
+      txb.transferObjects([txbResultToReturn!], txb.pure.address(transferToAddress!));
+    } else {
+      return txbResultToReturn;
+    }
+  }
+
+  public removeLiquidity({
+    pool,
+    amount,
+    mmtLpToken,
+    txb,
+    transferToAddress,
+  }: RemoveLiquidityOptions): Array<TransactionArgument> | undefined {
+    const txRes = txb.moveCall({
+      target: `${this.config.packageId}::spot_dex::remove_liquidity`,
+      typeArguments: [pool.tokenXType, pool.tokenYType],
+      arguments: [
+        txb.object(pool.objectId),
+        typeof mmtLpToken == 'string' ? txb.object(mmtLpToken) : mmtLpToken,
+        typeof amount == 'bigint' ? txb.pure.u64(amount) : amount,
+      ],
+    });
+
+    if (Boolean(transferToAddress)) {
+      txb.transferObjects([txRes[0]], txb.pure.address(transferToAddress!));
+      txb.transferObjects([txRes[1]], txb.pure.address(transferToAddress!));
+    } else {
+      return txRes;
+    }
+  }
+
+  public addLiquidity({
+    pool,
+    amountX,
+    amountY,
+    minAddAmountX,
+    minAddAmountY,
+    coinX,
+    coinY,
+    txb,
+    transferToAddress,
+  }: AddLiquidityOptions): TransactionArgument | undefined {
+    const [lpObject] = txb.moveCall({
+      target: `${this.config.packageId}::spot_dex::add_liquidity`,
+      typeArguments: [pool.tokenXType, pool.tokenYType],
+      arguments: [
+        txb.object(pool.objectId),
+        typeof coinY == 'string' ? txb.object(coinY) : coinY,
+        typeof coinX == 'string' ? txb.object(coinX) : coinX,
+        typeof amountY == 'bigint' ? txb.pure.u64(amountY) : amountY,
+        typeof amountX == 'bigint' ? txb.pure.u64(amountX) : amountX,
+        txb.pure.u64(minAddAmountY),
+        txb.pure.u64(minAddAmountX),
+      ],
+    });
+
+    if (Boolean(transferToAddress)) {
+      txb.transferObjects([lpObject], txb.pure.address(transferToAddress!));
+    } else {
+      return lpObject;
+    }
+  }
+
+  public async addLiquiditySingleSided({
+    pool,
+    inputCoinType,
+    inputCoinAmount,
+    inputCoin,
+    tokenInDecimals,
+    tokenOutDecimals,
+    swapSlippageTolerance,
+    txb,
+    transferToAddress,
+  }: AddLiquiditySingleSidedOptions): Promise<TransactionArgument | null | undefined> {
+    const isXtoY = pool.tokenXType === inputCoinType;
+    const amountToSwap = await getOptimalLpSwapAmount(
+      inputCoinAmount,
+      pool.objectId,
+      isXtoY,
+      this.suiClient,
+      pool?.isStable,
+    );
+
+    const coinToSwap = txb.splitCoins(
+      typeof inputCoin == 'string'
+        ? txb.object(inputCoin)
+        : (inputCoin as any as TransactionObjectArgument),
+      [typeof amountToSwap == 'bigint' ? txb.pure.u64(amountToSwap) : amountToSwap],
+    );
+
+    const tokenInPrice = await fetchCoinPrice(inputCoinType);
+    const tokenOutType = pool.tokenXType === inputCoinType ? pool.tokenYType : pool.tokenXType;
+    const tokenOutPrice = await fetchCoinPrice(tokenOutType);
+
+    const amountInUsd = (Number(amountToSwap) / 10 ** tokenInDecimals) * Number(tokenInPrice);
+    const minAmountOutUsd = amountInUsd * (1 - swapSlippageTolerance);
+    const minTokenOutAmount = BigInt(
+      Math.floor((minAmountOutUsd / Number(tokenOutPrice)) * 10 ** tokenOutDecimals),
+    );
+
+    const swappedCoin = this.swap({
+      pool,
+      inputCoinType,
+      inputCoinAmount: amountToSwap,
+      inputCoin: coinToSwap,
+      minReceived: minTokenOutAmount,
+      txb,
+    });
+
+    if (!swappedCoin) return null;
+
+    const coinX = isXtoY ? inputCoin : swappedCoin;
+    const coinY = isXtoY ? swappedCoin : inputCoin;
+    const coinXAmount = this.getCoinValue(pool.tokenXType, coinX, txb);
+    const coinYAmount = this.getCoinValue(pool.tokenYType, coinY, txb);
+
+    return this.addLiquidity({
+      pool,
+      amountX: coinXAmount,
+      amountY: coinYAmount,
+      minAddAmountX: BigInt(0),
+      minAddAmountY: BigInt(0),
+      coinX,
+      coinY,
+      txb,
+      transferToAddress,
+    });
+  }
+
+  public async getUserLpPositions({
+    pool,
+    userAddress,
+    maxIter = 5,
+    cursor: initialCursor = null,
+  }: GetUserLpPositionsOptions) {
+    let cursor: string | null | undefined = initialCursor;
+    const lpTokenType = `${this.config.packageId}::spot_dex::MmtLPToken<${pool.tokenXType},${pool.tokenYType}>`;
+    let data: any[] = [];
+    let iter = 0;
+    do {
+      const res: any = await this.suiClient.getOwnedObjects({
+        owner: userAddress,
+        filter: {
+          StructType: lpTokenType,
+        },
+        options: {
+          showContent: true,
+        },
+        cursor: cursor as string | null,
+        limit: 50,
+      });
+      data = [...data, ...res.data];
+      cursor = res.nextCursor;
+      iter++;
+    } while (cursor !== null && iter < maxIter);
+
+    return data
+      .filter((item) => (item.data.content as any).fields.pool_id == pool.objectId)
+      .map((item) => (item.data.content as any).fields);
+  }
+
+  public getSwapAmountStable({
+    reserveA,
+    reserveB,
+    scaleA,
+    scaleB,
+    amount,
+    totalFeeRate = BigInt(0),
+  }: GetSwapAmountStableOptions) {
+    let amountToSwapA = amount / BigInt(2);
+    let counter = 0;
+    let left = BigInt(0),
+      right = amount;
+    let recievedAmountB = BigInt(0);
+    // max 100 iterations for search
+    while (counter < 100) {
+      recievedAmountB = getPriceStable(
+        amountToSwapA,
+        reserveA,
+        reserveB,
+        totalFeeRate,
+        scaleA,
+        scaleB,
+      );
+      const userRatio = recievedAmountB / (amount - amountToSwapA);
+      // we are adding to reserveA, removing from reserveB
+      const reserveRatio =
+        (Number(reserveB) - Number(recievedAmountB)) / (Number(reserveA) + Number(amountToSwapA));
+
+      if (userRatio > reserveRatio) {
+        right = amountToSwapA;
+      } else {
+        left = amountToSwapA;
+      }
+
+      amountToSwapA = (left + right) / BigInt(2);
+      counter += 1;
+    }
+
+    return {
+      amountToSwap: amountToSwapA,
+      recievedAmount: recievedAmountB,
+    };
+  }
+
+  public getSwapAmountUncorrelated({
+    reserveA,
+    reserveB,
+    amount,
+    totalFeeRate = BigInt(0),
+  }: GetSwapAmountUncorrelatedOptions) {
+    let amountToSwapA = amount / BigInt(2);
+    let counter = 0;
+    let left = BigInt(0),
+      right = amount;
+    let recievedAmountB = BigInt(0);
+    while (counter < 100) {
+      recievedAmountB = getPriceUncorrelated(amountToSwapA, reserveA, reserveB, totalFeeRate);
+      const userRatio = recievedAmountB / (amount - amountToSwapA);
+      const reserveRatio =
+        (Number(reserveB) - Number(recievedAmountB)) / (Number(reserveA) + Number(amountToSwapA));
+
+      if (userRatio > reserveRatio) {
+        right = amountToSwapA;
+      } else {
+        left = amountToSwapA;
+      }
+
+      amountToSwapA = (left + right) / BigInt(2);
+      counter += 1;
+    }
+
+    return {
+      amountToSwap: amountToSwapA,
+      recievedAmount: recievedAmountB,
+    };
+  }
+
+  public getLpAmountIn({ amountX, amountY, lspSupply, reserveX, reserveY }: GetLpAmountInOptions) {
+    return bigIntMin([(amountX * lspSupply) / reserveX, (amountY * lspSupply) / reserveY]);
+  }
+
+  public getLpAmountOut({ lspAmount, lspSupply, reserveX, reserveY }: GetLpAmountOutOptions) {
+    return {
+      tokenX: reserveX * (lspAmount / lspSupply),
+      tokenY: reserveY * (lspAmount / lspSupply),
+    };
+  }
+
+  public mergeLpsTx = ({ txb, lps, typeX, typeY }: MergeLpsTxOptions) => {
+    if (lps.length > 1) {
+      lps.slice(1).forEach((lp) => {
+        txb.moveCall({
+          target: `${this.config.packageIdV1}::spot_dex::lp_token_join`,
+          arguments: [txb.object(lps[0]), txb.object(lp)],
+          typeArguments: [typeX, typeY],
+        });
+      });
+    }
+  };
+
+  public splitLpsTx = ({ txb, lp, amount, typeX, typeY }: SplitLpsTxOptions) => {
+    const [splitToken] = txb.moveCall({
+      target: `${this.config.packageIdV1}::spot_dex::lp_token_split`,
+      arguments: [typeof lp == 'string' ? txb.object(lp) : lp, txb.pure.u64(amount)],
+      typeArguments: [typeX, typeY],
+    });
+
+    return splitToken;
+  };
+}

package/src/sdk/sdkBase.ts

@@ -0,0 +1,199 @@
+import {
+  TransactionArgument,
+  Transaction,
+  TransactionObjectArgument,
+} from '@mysten/sui/transactions';
+import { CoinStruct, SuiClient } from '@mysten/sui/client';
+import { DexConstants, NETWORK_CONFIG } from '../utils/constants';
+import { GetExactCoinByAmountOptions, SdkOptions, Network } from '../utils/types';
+
+class SdkBase {
+  suiClient: SuiClient;
+  network: Network;
+  config: typeof NETWORK_CONFIG.mainnet;
+
+  constructor(options: SdkOptions | string) {
+    if (typeof options === 'string') {
+      this.suiClient = new SuiClient({ url: options });
+      this.network = 'mainnet';
+      this.config = NETWORK_CONFIG.mainnet;
+    } else {
+      this.suiClient = new SuiClient({ url: options.rpcEndpoint });
+      this.network = options.network ?? 'mainnet';
+      this.config = NETWORK_CONFIG[this.network];
+    }
+  }
+
+  public getSuiCoin(amount: bigint | TransactionArgument, txb: Transaction): TransactionArgument {
+    const inputCoinAmount = typeof amount === 'bigint' ? txb.pure.u64(amount) : amount;
+    const [coin] = txb.splitCoins(txb.gas, [inputCoinAmount]);
+    return coin;
+  }
+
+  public mergeCoins(
+    coinObjects: Array<string | TransactionArgument>,
+    txb: Transaction,
+  ): TransactionArgument | undefined {
+    if (coinObjects.length == 1) {
+      return typeof coinObjects[0] == 'string' ? txb.object(coinObjects[0]) : coinObjects[0];
+    }
+    let firstCoin =
+      typeof coinObjects[0] == 'string'
+        ? txb.object(coinObjects[0])
+        : (coinObjects[0] as any as TransactionObjectArgument);
+    txb.mergeCoins(
+      firstCoin,
+      coinObjects
+        .slice(1)
+        .map((coin) =>
+          typeof coin == 'string' ? txb.object(coin) : (coin as any as TransactionObjectArgument),
+        ),
+    );
+    return firstCoin;
+  }
+
+  public getCoinValue(
+    coinType: string,
+    coinObject: string | TransactionArgument,
+    txb: Transaction,
+  ): TransactionArgument {
+    const inputCoinObject = typeof coinObject == 'string' ? txb.object(coinObject) : coinObject;
+    let [value] = txb.moveCall({
+      target: `0x2::coin::value`,
+      typeArguments: [coinType],
+
+      arguments: [inputCoinObject],
+    });
+    return value;
+  }
+
+  public getExactCoinByAmount({ coinType, coins, amount, txb }: GetExactCoinByAmountOptions) {
+    if (coinType === DexConstants.suiCoinType) {
+      const [coinA] = txb.splitCoins(txb.gas, [txb.pure.u64(amount)]);
+      return coinA;
+    } else {
+      const coinsX = this.getCoinsGreaterThanAmount(amount, coins);
+
+      if (coinsX.length > 1) {
+        txb.mergeCoins(
+          txb.object(coinsX[0]),
+          coinsX.slice(1).map((coin) => txb.object(coin)),
+        );
+      }
+
+      const [coinA] = txb.splitCoins(txb.object(coinsX[0]), [txb.pure.u64(amount)]);
+      return coinA;
+    }
+  }
+
+  public mergeAllUserCoins = async (coinType: string, signerAddress: string) => {
+    try {
+      const coins = await this.getAllUserCoins({
+        address: signerAddress,
+        type: coinType,
+      });
+
+      let totalBalance = BigInt(0);
+
+      coins.forEach((coin) => {
+        totalBalance += BigInt(coin.balance);
+      });
+
+      const txb = new Transaction();
+
+      if (coinType === DexConstants.suiCoinType) {
+        totalBalance = totalBalance - BigInt('1000');
+        txb.splitCoins(txb.gas, [txb.pure.u64(totalBalance)]);
+      }
+
+      const coinObjectsIds = coins.map((coin) => coin.coinObjectId);
+
+      if (coins.length > 1) {
+        txb.mergeCoins(
+          txb.object(coinObjectsIds[0]),
+          coinObjectsIds.slice(1).map((coin) => txb.object(coin)),
+        );
+      }
+
+      return txb;
+    } catch (error) {
+      console.log(error);
+    }
+  };
+
+  public mergeAllCoinsWithoutFetch(coins: CoinStruct[], coinType: string, txb: Transaction) {
+    let totalBalance = BigInt(0);
+    coins.forEach((coin) => {
+      totalBalance += BigInt(coin.balance);
+    });
+
+    if (coinType === DexConstants.suiCoinType) {
+      totalBalance = totalBalance - BigInt('1000');
+      txb.splitCoins(txb.gas, [txb.pure.u64(totalBalance)]);
+    }
+
+    const coinObjectsIds = coins.map((coin) => coin.coinObjectId);
+
+    if (coins.length > 1) {
+      txb.mergeCoins(
+        txb.object(coinObjectsIds[0]),
+        coinObjectsIds.slice(1).map((coin) => txb.object(coin)),
+      );
+    }
+  }
+
+  public getAllUserCoins = async ({ address, type }: { type: string; address: string }) => {
+    let cursor: string | null | undefined;
+
+    let coins: CoinStruct[] = [];
+    let iter = 0;
+
+    do {
+      try {
+        const res = await this.suiClient.getCoins({
+          owner: address,
+          coinType: type,
+          cursor: cursor,
+          limit: 50,
+        });
+        coins = coins.concat(res.data);
+        cursor = res.nextCursor;
+        if (!res.hasNextPage || iter === 8) {
+          cursor = null;
+        }
+      } catch (error) {
+        console.log(error);
+        cursor = null;
+      }
+      iter++;
+    } while (cursor !== null && cursor !== undefined);
+
+    return coins;
+  };
+
+  private getCoinsGreaterThanAmount = (
+    amount: bigint,
+    coins: { objectId: string; balance: bigint }[],
+  ) => {
+    const coinsWithBalance: string[] = [];
+
+    let collectedAmount = BigInt(0);
+
+    for (const coin of coins) {
+      if (collectedAmount < amount && !coinsWithBalance.includes(coin.objectId)) {
+        coinsWithBalance.push(coin.objectId);
+        collectedAmount = collectedAmount + coin.balance;
+      }
+      if (coin.balance === BigInt(0) && !coinsWithBalance.includes(coin.objectId))
+        coinsWithBalance.push(coin.objectId);
+    }
+
+    if (collectedAmount >= amount) {
+      return coinsWithBalance;
+    } else {
+      throw new Error('Insufficient balance');
+    }
+  };
+}
+
+export { SdkBase };