@cetusprotocol/aggregator-sdk 1.2.0 → 1.2.1

package/dist/index.js

@@ -2851,37 +2851,61 @@ var TransactionErrorCode = /* @__PURE__ */ ((TransactionErrorCode2) => {
   TransactionErrorCode2["MissAftermathLpSupplyType"] = `MissAftermathLpSupplyType`;
   return TransactionErrorCode2;
 })(TransactionErrorCode || {});
+var AggregatorError = class _AggregatorError extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.message = message;
+    this.errorCode = errorCode;
+  }
+  static isAggregatorErrorCode(e, code) {
+    return e instanceof _AggregatorError && e.errorCode === code;
+  }
+};
 var AggregatorServerErrorCode = /* @__PURE__ */ ((AggregatorServerErrorCode2) => {
   AggregatorServerErrorCode2[AggregatorServerErrorCode2["NumberTooLarge"] = 1e3] = "NumberTooLarge";
   AggregatorServerErrorCode2[AggregatorServerErrorCode2["RateLimitExceeded"] = 1001] = "RateLimitExceeded";
   AggregatorServerErrorCode2[AggregatorServerErrorCode2["InsufficientLiquidity"] = 1002] = "InsufficientLiquidity";
   AggregatorServerErrorCode2[AggregatorServerErrorCode2["HoneyPot"] = 1003] = "HoneyPot";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["BadRequest"] = 1004] = "BadRequest";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["Forbidden"] = 1005] = "Forbidden";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["InternalServerError"] = 1006] = "InternalServerError";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["NotFoundRoute"] = 1007] = "NotFoundRoute";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["ServiceUnavailable"] = 1008] = "ServiceUnavailable";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["UnsupportedApiVersion"] = 1009] = "UnsupportedApiVersion";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["HoneyPotScam"] = 1010] = "HoneyPotScam";
+  AggregatorServerErrorCode2[AggregatorServerErrorCode2["UnknownError"] = 400] = "UnknownError";
   return AggregatorServerErrorCode2;
 })(AggregatorServerErrorCode || {});
-function getAggregatorServerErrorMessage(code) {
+function getAggregatorServerErrorMessage(code, msg) {
   switch (code) {
     case 1e3 /* NumberTooLarge */:
-      return "Number too large";
+      return "Number too large" + (msg ? `: ${msg}` : "");
     case 1001 /* RateLimitExceeded */:
-      return "Rate limit exceeded";
+      return "Rate limit exceeded" + (msg ? `: ${msg}` : "");
     case 1002 /* InsufficientLiquidity */:
-      return "Insufficient liquidity";
+      return "Insufficient liquidity" + (msg ? `: ${msg}` : "");
     case 1003 /* HoneyPot */:
-      return "HoneyPot scam detected";
+      return "HoneyPot scam detected" + (msg ? `: ${msg}` : "");
+    case 1005 /* Forbidden */:
+      return "Forbidden" + (msg ? `: ${msg}` : "");
+    case 1004 /* BadRequest */:
+      return "Bad request" + (msg ? `: ${msg}` : "");
+    case 1006 /* InternalServerError */:
+      return "Internal server error" + (msg ? `: ${msg}` : "");
+    case 1007 /* NotFoundRoute */:
+      return "Not found route" + (msg ? `: ${msg}` : "");
+    case 1008 /* ServiceUnavailable */:
+      return "Service unavailable" + (msg ? `: ${msg}` : "");
+    case 1009 /* UnsupportedApiVersion */:
+      return "Unsupported API version" + (msg ? `: ${msg}` : "");
+    case 1010 /* HoneyPotScam */:
+      return "Detected HoneyPot Scam" + (msg ? `: ${msg}` : "");
+    case 400 /* UnknownError */:
+      return "Unknown error" + (msg ? `: ${msg}` : "");
     default:
       return "Unknown error";
   }
 }
-var AggregatorError = class _AggregatorError extends Error {
-  constructor(message, errorCode) {
-    super(message);
-    this.message = message;
-    this.errorCode = errorCode;
-  }
-  static isAggregatorErrorCode(e, code) {
-    return e instanceof _AggregatorError && e.errorCode === code;
-  }
-};
 var EQUAL = 0;
 var LESS_THAN = 1;
 var GREATER_THAN = 2;
@@ -3429,7 +3453,7 @@ var AGGREGATOR_V3_CONFIG = {
 };
 
 // src/api.ts
-var SDK_VERSION = 1010200;
+var SDK_VERSION = 1010201;
 function parseRouterResponse(data, byAmountIn) {
   let packages = /* @__PURE__ */ new Map();
   if (data.packages) {
@@ -3464,6 +3488,50 @@ function parseRouterResponse(data, byAmountIn) {
     }))
   };
 }
+function parseMergeSwapResponse(data) {
+  var _a;
+  let packages = /* @__PURE__ */ new Map();
+  if (data.packages) {
+    if (data.packages instanceof Map) {
+      packages = data.packages;
+    } else if (typeof data.packages === "object") {
+      Object.entries(data.packages).forEach(([key, value]) => {
+        packages.set(key, value);
+      });
+    }
+  }
+  const allRoutes = [];
+  if (data.all_routes) {
+    for (const route of data.all_routes) {
+      const mergeRoute = {
+        amountIn: new import_bn2.default(route.amount_in.toString()),
+        amountOut: new import_bn2.default(route.amount_out.toString()),
+        deviationRatio: route.deviation_ratio,
+        paths: route.paths.map((path) => ({
+          id: path.id,
+          direction: path.direction,
+          provider: path.provider,
+          from: path.from,
+          target: path.target,
+          feeRate: path.fee_rate,
+          amountIn: path.amount_in.toString(),
+          amountOut: path.amount_out.toString(),
+          version: path.version,
+          publishedAt: path.published_at,
+          extendedDetails: path.extended_details
+        }))
+      };
+      allRoutes.push(mergeRoute);
+    }
+  }
+  return {
+    quoteID: data.request_id || "",
+    totalAmountOut: new import_bn2.default(((_a = data.total_amount_out) == null ? void 0 : _a.toString()) || "0"),
+    allRoutes,
+    packages,
+    gas: data.gas
+  };
+}
 function getRouterResult(endpoint, apiKey, params, overlayFee, overlayFeeReceiver) {
   return __async(this, null, function* () {
     let response;
@@ -3476,7 +3544,7 @@ function getRouterResult(endpoint, apiKey, params, overlayFee, overlayFeeReceive
       return null;
     }
     if (!response.ok) {
-      let errorCode = 1e3 /* NumberTooLarge */;
+      let errorCode = 1004 /* BadRequest */;
       if (response.status === 429) {
         errorCode = 1001 /* RateLimitExceeded */;
       }
@@ -3495,24 +3563,6 @@ function getRouterResult(endpoint, apiKey, params, overlayFee, overlayFeeReceive
       };
     }
     const data = JSONbig__default.default.parse(yield response.text());
-    const insufficientLiquidity = data.msg === "liquidity is not enough";
-    if (data.msg && data.msg.indexOf("HoneyPot scam") > -1) {
-      return {
-        quoteID: "",
-        amountIn: ZERO,
-        amountOut: ZERO,
-        paths: [],
-        byAmountIn: params.byAmountIn,
-        insufficientLiquidity,
-        deviationRatio: 0,
-        error: {
-          code: 1003 /* HoneyPot */,
-          msg: getAggregatorServerErrorMessage(
-            1003 /* HoneyPot */
-          )
-        }
-      };
-    }
     if (data.data != null) {
       const res = parseRouterResponse(data.data, params.byAmountIn);
       if (overlayFee > 0 && overlayFeeReceiver !== "0x0") {
@@ -3537,6 +3587,9 @@ function getRouterResult(endpoint, apiKey, params, overlayFee, overlayFeeReceive
       }
       return res;
     }
+    const code = processErrorStatusCode(data.code);
+    const msg = getAggregatorServerErrorMessage(code, data.msg);
+    const insufficientLiquidity = msg.includes("Insufficient liquidity");
     return {
       quoteID: "",
       amountIn: ZERO,
@@ -3546,10 +3599,8 @@ function getRouterResult(endpoint, apiKey, params, overlayFee, overlayFeeReceive
       byAmountIn: params.byAmountIn,
       deviationRatio: 0,
       error: {
-        code: 1002 /* InsufficientLiquidity */,
-        msg: getAggregatorServerErrorMessage(
-          1002 /* InsufficientLiquidity */
-        )
+        code,
+        msg
       }
     };
   });
@@ -3651,6 +3702,103 @@ function postRouterWithLiquidityChanges(endpoint, params) {
     }
   });
 }
+function getMergeSwapRouter(endpoint, apiKey, params) {
+  return __async(this, null, function* () {
+    try {
+      const { target, byAmountIn, depth, providers, froms } = params;
+      const targetCoin = completionCoin(target);
+      let url = `${endpoint}/multi_find_routes?target=${targetCoin}&by_amount_in=${byAmountIn}`;
+      if (depth) {
+        url += `&depth=${depth}`;
+      }
+      if (providers && providers.length > 0) {
+        url += `&providers=${providers.join(",")}`;
+      }
+      if (apiKey.length > 0) {
+        url += `&apiKey=${apiKey}`;
+      }
+      url += `&v=${SDK_VERSION}`;
+      const fromsData = froms.map((from) => ({
+        coin_type: completionCoin(from.coinType),
+        amount: Number(from.amount.toString())
+      }));
+      url += `&froms=${encodeURIComponent(JSON.stringify(fromsData))}`;
+      const response = yield fetch(url);
+      console.log("response", response);
+      return response;
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  });
+}
+function getMergeSwapResult(endpoint, apiKey, params, overlayFee, overlayFeeReceiver) {
+  return __async(this, null, function* () {
+    const response = yield getMergeSwapRouter(endpoint, apiKey, params);
+    if (!response) {
+      return null;
+    }
+    if (!response.ok) {
+      let errorCode = 1004 /* BadRequest */;
+      if (response.status === 429) {
+        errorCode = 1001 /* RateLimitExceeded */;
+      }
+      return {
+        quoteID: "",
+        totalAmountOut: ZERO,
+        allRoutes: [],
+        error: {
+          code: errorCode,
+          msg: getAggregatorServerErrorMessage(errorCode)
+        }
+      };
+    }
+    if (!response.ok) {
+      const code2 = processErrorStatusCode(response.status);
+      const responseText2 = yield response.text();
+      const data2 = JSONbig__default.default.parse(responseText2);
+      const msg2 = getAggregatorServerErrorMessage(code2, data2.msg);
+      return {
+        quoteID: "",
+        totalAmountOut: ZERO,
+        allRoutes: [],
+        error: {
+          code: code2,
+          msg: msg2
+        }
+      };
+    }
+    const responseText = yield response.text();
+    const data = JSONbig__default.default.parse(responseText);
+    if (data.data != null) {
+      console.log("data.data not null", data.data);
+      const res = parseMergeSwapResponse(data.data);
+      if (overlayFee > 0 && overlayFeeReceiver !== "0x0" && params.byAmountIn) {
+        const overlayFeeAmount = res.totalAmountOut.mul(new import_bn2.default(overlayFee)).div(new import_bn2.default(1e6));
+        res.totalAmountOut = res.totalAmountOut.sub(overlayFeeAmount);
+        for (const route of res.allRoutes) {
+          const routeFee = route.amountOut.mul(new import_bn2.default(overlayFee)).div(new import_bn2.default(1e6));
+          route.amountOut = route.amountOut.sub(routeFee);
+        }
+      }
+      if (!res.packages) {
+        res.packages = /* @__PURE__ */ new Map();
+      }
+      return res;
+    }
+    const code = processErrorStatusCode(data.code);
+    const msg = getAggregatorServerErrorMessage(code, data.msg);
+    return {
+      quoteID: "",
+      totalAmountOut: ZERO,
+      allRoutes: [],
+      error: {
+        code,
+        msg
+      }
+    };
+  });
+}
 function getDeepbookV3Config(endpoint) {
   return __async(this, null, function* () {
     const url = `${endpoint}/deepbookv3_config`;
@@ -3696,6 +3844,32 @@ function processFlattenRoutes(routerData) {
     overlayFee: routerData.overlayFee
   };
 }
+function processErrorStatusCode(status) {
+  switch (status) {
+    case 400:
+      return 1004 /* BadRequest */;
+    case 403:
+      return 1005 /* Forbidden */;
+    case 429:
+      return 1001 /* RateLimitExceeded */;
+    case 4e3:
+      return 1004 /* BadRequest */;
+    case 4030:
+      return 1005 /* Forbidden */;
+    case 4040:
+      return 1010 /* HoneyPotScam */;
+    case 5e3:
+      return 1002 /* InsufficientLiquidity */;
+    case 5001:
+      return 1007 /* NotFoundRoute */;
+    case 5030:
+      return 1008 /* ServiceUnavailable */;
+    case 5040:
+      return 1009 /* UnsupportedApiVersion */;
+    default:
+      return 400 /* UnknownError */;
+  }
+}
 
 // src/config.ts
 var Env = /* @__PURE__ */ ((Env2) => {
@@ -8107,6 +8281,53 @@ var FullsailRouter = class {
     });
   }
 };
+var CetusDlmmRouter = class {
+  constructor(env, partner) {
+    if (env !== 0 /* Mainnet */) {
+      throw new Error("CetusRouter only supported on mainnet");
+    }
+    this.globalConfig = "0xf31b605d117f959b9730e8c07b08b856cb05143c5e81d5751c90d2979e82f599";
+    this.partner = partner != null ? partner : "0x59ae16f6c42f578063c2da9b9c0173fe58120ceae08e40fd8212c8eceb80bb86";
+    this.versioned = "0x05370b2d656612dd5759cbe80463de301e3b94a921dfc72dd9daa2ecdeb2d0a8";
+  }
+  swap(txb, flattenedPath, swapContext, _extends) {
+    const swapData = this.prepareSwapData(flattenedPath);
+    this.executeSwapContract(txb, swapData, swapContext);
+  }
+  prepareSwapData(flattenedPath) {
+    if (flattenedPath.path.publishedAt == null) {
+      throw new Error("Cetus not set publishedAt");
+    }
+    const path = flattenedPath.path;
+    const [coinAType, coinBType] = path.direction ? [path.from, path.target] : [path.target, path.from];
+    const amountIn = flattenedPath.isLastUseOfIntermediateToken ? AGGREGATOR_V3_CONFIG.MAX_AMOUNT_IN : path.amountIn;
+    return {
+      coinAType,
+      coinBType,
+      direction: path.direction,
+      amountIn,
+      publishedAt: path.publishedAt,
+      poolId: path.id
+    };
+  }
+  executeSwapContract(txb, swapData, swapContext) {
+    const args = [
+      swapContext,
+      txb.object(this.globalConfig),
+      txb.object(swapData.poolId),
+      txb.object(this.partner),
+      txb.pure.bool(swapData.direction),
+      txb.pure.u64(swapData.amountIn),
+      txb.object(this.versioned),
+      txb.object(utils.SUI_CLOCK_OBJECT_ID)
+    ];
+    txb.moveCall({
+      target: `${swapData.publishedAt}::cetus_dlmm::swap`,
+      typeArguments: [swapData.coinAType, swapData.coinBType],
+      arguments: args
+    });
+  }
+};
 
 // src/client.ts
 var CETUS = "CETUS";
@@ -8139,6 +8360,7 @@ var MAGMA = "MAGMA";
 var SEVENK = "SEVENK";
 var HAEDALHMMV2 = "HAEDALHMMV2";
 var FULLSAIL = "FULLSAIL";
+var CETUSDLMM = "CETUSDLMM";
 var DEFAULT_ENDPOINT = "https://api-sui.cetus.zone/router_v3";
 var ALL_DEXES = [
   CETUS,
@@ -8169,7 +8391,8 @@ var ALL_DEXES = [
   MAGMA,
   SEVENK,
   HAEDALHMMV2,
-  FULLSAIL
+  FULLSAIL,
+  CETUSDLMM
 ];
 function getAllProviders() {
   return ALL_DEXES;
@@ -8248,6 +8471,7 @@ var _AggregatorClient = class _AggregatorClient {
     );
     this.apiKey = params.apiKey || "";
     this.partner = params.partner;
+    this.cetusDlmmPartner = params.cetusDlmmPartner;
     if (params.overlayFeeRate) {
       if (params.overlayFeeRate > 0 && params.overlayFeeRate <= CLIENT_CONFIG.MAX_OVERLAY_FEE_RATE) {
         this.overlayFeeRate = params.overlayFeeRate * AGGREGATOR_V3_CONFIG.FEE_DENOMINATOR;
@@ -8313,11 +8537,22 @@ var _AggregatorClient = class _AggregatorClient {
       );
     });
   }
+  findMergeSwapRouters(params) {
+    return __async(this, null, function* () {
+      return getMergeSwapResult(
+        this.endpoint,
+        this.apiKey,
+        params,
+        this.overlayFeeRate,
+        this.overlayFeeReceiver
+      );
+    });
+  }
   executeFlexibleInputSwap(txb, inputCoin, routerData, expectedAmountOut, amountLimit, pythPriceIDs, partner, deepbookv3DeepFee, packages) {
     return __async(this, null, function* () {
     });
   }
-  newDexRouterV3(provider, pythPriceIDs, partner) {
+  newDexRouterV3(provider, pythPriceIDs, partner, cetusDlmmPartner) {
     switch (provider) {
       case CETUS:
         return new CetusRouter(this.env, partner);
@@ -8377,13 +8612,15 @@ var _AggregatorClient = class _AggregatorClient {
         return new HaedalHMMV2Router(this.env, pythPriceIDs);
       case FULLSAIL:
         return new FullsailRouter(this.env);
+      case CETUSDLMM:
+        return new CetusDlmmRouter(this.env, cetusDlmmPartner);
       default:
         throw new Error(
           `${CLIENT_CONFIG.ERRORS.UNSUPPORTED_DEX} ${provider}`
         );
     }
   }
-  expectInputSwapV3(txb, inputCoin, routerData, expectAmountOut, amountOutLimit, pythPriceIDs, partner) {
+  expectInputSwapV3(txb, inputCoin, routerData, expectAmountOut, amountOutLimit, pythPriceIDs, partner, cetusDlmmPartner) {
     if (routerData.quoteID == null) {
       throw new Error(CLIENT_CONFIG.ERRORS.QUOTE_ID_REQUIRED);
     }
@@ -8408,7 +8645,12 @@ var _AggregatorClient = class _AggregatorClient {
       if (!dexRouters.has(path.provider)) {
         dexRouters.set(
           path.provider,
-          this.newDexRouterV3(path.provider, pythPriceIDs, partner)
+          this.newDexRouterV3(
+            path.provider,
+            pythPriceIDs,
+            partner,
+            cetusDlmmPartner
+          )
         );
       }
       const dex = dexRouters.get(path.provider);
@@ -8650,6 +8892,103 @@ var _AggregatorClient = class _AggregatorClient {
       }
     });
   }
+  mergeSwap(params) {
+    return __async(this, null, function* () {
+      const { router, inputCoins, slippage, txb, partner } = params;
+      if (slippage > 1 || slippage < 0) {
+        throw new Error(CLIENT_CONFIG.ERRORS.INVALID_SLIPPAGE);
+      }
+      if (!router.packages || !router.packages.get(PACKAGE_NAMES.AGGREGATOR_V3)) {
+        throw new Error(CLIENT_CONFIG.ERRORS.PACKAGES_REQUIRED);
+      }
+      if (!router.allRoutes || router.allRoutes.length === 0) {
+        throw new Error("No routes found in merge swap response");
+      }
+      const outputCoins = [];
+      for (let i = 0; i < router.allRoutes.length && i < inputCoins.length; i++) {
+        const route = router.allRoutes[i];
+        const inputCoin = inputCoins[i];
+        const routeRouter = {
+          quoteID: router.quoteID,
+          amountIn: route.amountIn,
+          amountOut: route.amountOut,
+          deviationRatio: Number(route.deviationRatio),
+          byAmountIn: true,
+          // Merge swap is always by amount in
+          paths: route.paths,
+          insufficientLiquidity: false,
+          packages: router.packages
+        };
+        const routerParams = {
+          router: routeRouter,
+          inputCoin: inputCoin.coin,
+          slippage,
+          txb,
+          partner: partner != null ? partner : this.partner
+        };
+        const outputCoin = yield this.routerSwap(routerParams);
+        outputCoins.push(outputCoin);
+      }
+      if (outputCoins.length === 0) {
+        throw new Error("No output coins generated from merge swap");
+      }
+      let finalOutputCoin = outputCoins[0];
+      if (outputCoins.length > 1) {
+        txb.mergeCoins(finalOutputCoin, outputCoins.slice(1));
+      }
+      return finalOutputCoin;
+    });
+  }
+  fastMergeSwap(params) {
+    return __async(this, null, function* () {
+      const { router, slippage, txb, partner } = params;
+      if (!router || !router.allRoutes || router.allRoutes.length === 0) {
+        throw new Error("Invalid router: no routes found");
+      }
+      const firstRoute = router.allRoutes[0];
+      const targetCoinType = firstRoute.paths[firstRoute.paths.length - 1].target;
+      const inputCoins = [];
+      const coinTypeSet = /* @__PURE__ */ new Set();
+      for (const route of router.allRoutes) {
+        const firstCoinType = route.paths[0].from;
+        if (coinTypeSet.has(firstCoinType)) {
+          continue;
+        }
+        coinTypeSet.add(firstCoinType);
+        const coin = transactions.coinWithBalance({
+          balance: BigInt(route.amountIn.toString()),
+          useGasCoin: CoinUtils.isSuiCoin(firstCoinType),
+          type: firstCoinType
+        });
+        inputCoins.push({ coinType: firstCoinType, coin });
+      }
+      const mergeSwapParams = {
+        router,
+        inputCoins,
+        slippage,
+        txb,
+        partner: partner != null ? partner : this.partner
+      };
+      const targetCoin = yield this.mergeSwap(mergeSwapParams);
+      if (CoinUtils.isSuiCoin(targetCoinType)) {
+        txb.mergeCoins(txb.gas, [targetCoin]);
+      } else {
+        const targetCoinObjID = yield this.getOneCoinUsedToMerge(targetCoinType);
+        if (targetCoinObjID != null) {
+          txb.mergeCoins(txb.object(targetCoinObjID), [targetCoin]);
+        } else {
+          transferOrDestroyCoin(
+            {
+              coin: targetCoin,
+              coinType: targetCoinType,
+              packages: router.packages
+            },
+            txb
+          );
+        }
+      }
+    });
+  }
   fixableRouterSwapV3(params) {
     return __async(this, null, function* () {
       const { router, inputCoin, slippage, txb, partner } = params;
@@ -8943,6 +9282,7 @@ exports.AggregatorServerErrorCode = AggregatorServerErrorCode;
 exports.BLUEFIN = BLUEFIN;
 exports.BLUEMOVE = BLUEMOVE;
 exports.CETUS = CETUS;
+exports.CETUSDLMM = CETUSDLMM;
 exports.CETUS_DEX = CETUS_DEX;
 exports.CETUS_MODULE = CETUS_MODULE;
 exports.CETUS_PUBLISHED_AT = CETUS_PUBLISHED_AT;
@@ -9081,6 +9421,7 @@ exports.getAggregatorV2PublishedAt = getAggregatorV2PublishedAt;
 exports.getAllProviders = getAllProviders;
 exports.getDeepbookV3Config = getDeepbookV3Config;
 exports.getDefaultSuiInputType = getDefaultSuiInputType;
+exports.getMergeSwapResult = getMergeSwapResult;
 exports.getOrCreateAccountCap = getOrCreateAccountCap;
 exports.getProvidersExcluding = getProvidersExcluding;
 exports.getProvidersIncluding = getProvidersIncluding;