@scallop-io/scallop-swap-sdk 1.0.0

package/src/interface/route.ts

@@ -0,0 +1,33 @@
+export interface Coin {
+  type: string;
+  amount: bigint;
+}
+
+interface SwapCoinInfo {
+  coinIn: Coin;
+  coinOut: Coin;
+}
+
+interface SwapPath extends SwapCoinInfo {
+  protocolName: string;
+}
+
+export interface SwapRoute extends SwapCoinInfo {
+  paths: SwapPath[];
+  splitPercentage?: number; // for multi route swap
+}
+
+/**
+ * Common interface for route result (for frontend display purposes)
+ */
+export interface FormattedRouteResult {
+  routes: SwapRoute[];
+  coinIn: Coin; // Input coin info
+  coinOut: Coin; // Output coin info
+  name: string; // Aggregator name
+}
+
+export type FetchRouteResult<T> = {
+  rawRouteResult: T; // The raw route result from the aggregator
+  formattedResult: FormattedRouteResult; // The formatted route result for frontend display
+};

package/src/sdk/7k.ts

@@ -0,0 +1,231 @@
+import {
+  buildTx,
+  getQuote,
+  setSuiClient,
+  Commission,
+  QuoteResponse,
+  SorRoute,
+  SourceDex,
+} from '@7kprotocol/sdk-ts';
+import { Transaction, TransactionObjectArgument } from '@scallop-io/sui-kit';
+import { SwapSdkBase } from 'src/class';
+import {
+  FetchRouteParams,
+  FetchRouteResult,
+  FormattedRouteResult,
+  SwapParams,
+  SwapRoute,
+  SwapSdkConstructorParams,
+} from 'src/interface';
+import { BigNumber } from 'bignumber.js';
+import { transformProperCase } from 'src/utils';
+
+// From 7k SDK
+interface Params {
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: string;
+  /**
+   * @default DEFAULT_SOURCES
+   * @warning BluefinX must be explicitly specified if needed
+   * @example ```sources: [...DEFAULT_SOURCES, "bluefinx"]``` */
+  sources?: SourceDex[];
+  commissionBps?: number;
+  /** Limit the route to a specific set of pools */
+  targetPools?: string[];
+  /** Exclude a specific set of pools from the route */
+  excludedPools?: string[];
+  /** The taker address, required for bluefinx */
+  taker?: string;
+  /** If true, excludes all liquidity sources that depend on pyth price feeds - pyth client use tx.gas to pay the fee*/
+  isSponsored?: boolean;
+}
+
+export class _7kSwap extends SwapSdkBase<
+  SourceDex,
+  QuoteResponse,
+  Omit<Params, 'tokenIn' | 'tokenOut' | 'amountIn'>
+> {
+  commission: Commission;
+  constructor(params: SwapSdkConstructorParams & { commission?: Commission }) {
+    super('7k', params);
+    this.commission = params.commission ?? {
+      partner: this.walletAddress,
+      commissionBps: 0,
+    };
+    setSuiClient(this.client);
+  }
+
+  setFetchRouteSettings(
+    settings: Omit<Params, 'tokenIn' | 'tokenOut' | 'amountIn'>
+  ) {
+    this.fetchSettings = settings;
+  }
+
+  private createRoute(
+    sorRoute: SorRoute[],
+    coinInDecimal: number,
+    coinOutDecimal: number
+  ): SwapRoute[] {
+    const routes: SwapRoute[] = [];
+    sorRoute.forEach((r, idx) => {
+      routes.push({
+        paths: [],
+        coinIn: {
+          type: r.tokenIn,
+          amount: BigInt(
+            BigNumber(r.tokenInAmount)
+              .multipliedBy(coinInDecimal)
+              .integerValue()
+              .toString()
+          ),
+        },
+        coinOut: {
+          type: r.tokenOut,
+          amount: BigInt(
+            BigNumber(r.tokenOutAmount)
+              .multipliedBy(coinOutDecimal)
+              .integerValue()
+              .toString()
+          ),
+        },
+      });
+
+      r.hops.forEach((h) => {
+        routes[idx].paths.push({
+          protocolName: transformProperCase(
+            h.pool.type.toLowerCase() as Lowercase<string>
+          ),
+          coinIn: {
+            type: h.tokenIn,
+            amount: BigInt(
+              BigNumber(h.tokenInAmount)
+                .multipliedBy(coinInDecimal)
+                .integerValue()
+                .toString()
+            ),
+          },
+          coinOut: {
+            type: h.tokenOut,
+            amount: BigInt(
+              BigNumber(h.tokenOutAmount)
+                .multipliedBy(coinOutDecimal)
+                .integerValue()
+                .toString()
+            ),
+          },
+        });
+      });
+    });
+
+    const totalSwapAmount = routes
+      .reduce((acc, r) => acc + r.coinIn.amount, BigInt(0))
+      .toString();
+    routes.forEach((r) => {
+      r.splitPercentage = BigNumber(r.coinIn.amount.toString())
+        .div(totalSwapAmount)
+        .times(100)
+        .toNumber();
+    });
+    return routes;
+  }
+
+  private parseRawRouteToFormattedResult(
+    rawRoute: QuoteResponse
+  ): FormattedRouteResult {
+    if (!rawRoute.routes) {
+      throw new Error(`${this.name} fetch route returned empty sorRoute`);
+    }
+    return {
+      routes: this.createRoute(
+        rawRoute.routes,
+        BigNumber(rawRoute.swapAmountWithDecimal)
+          .dividedBy(rawRoute.swapAmount)
+          .toNumber(),
+        BigNumber(rawRoute.returnAmountAfterCommissionWithDecimal)
+          .dividedBy(rawRoute.returnAmount)
+          .toNumber()
+      ),
+      coinIn: {
+        type: rawRoute.tokenIn,
+        amount: BigInt(rawRoute.swapAmountWithDecimal),
+      },
+      coinOut: {
+        type: rawRoute.tokenOut,
+        amount: BigInt(rawRoute.returnAmountAfterCommissionWithDecimal),
+      },
+      name: this.name,
+    };
+  }
+
+  async fetchRoute(
+    params: FetchRouteParams
+  ): Promise<FetchRouteResult<QuoteResponse>> {
+    const normalizedParams = this.normalizeFetchRouteParams(params);
+
+    const { coinInType, coinOutType, swapAmount } = normalizedParams;
+    const rawRouteResult = await this.withTimeout(
+      getQuote({
+        tokenIn: coinInType,
+        tokenOut: coinOutType,
+        amountIn: swapAmount.toString(),
+        ...this.fetchSettings,
+      })
+    );
+
+    if (!rawRouteResult) {
+      throw new Error(`${this.name} fetch route returned empty response`);
+    }
+
+    this.rawRouteResult = rawRouteResult;
+
+    return {
+      formattedResult: this.parseRawRouteToFormattedResult(rawRouteResult),
+      rawRouteResult,
+    };
+  }
+
+  async buildSwapTransaction(
+    params: SwapParams
+  ): Promise<{ tx: Transaction; coinOut: TransactionObjectArgument }> {
+    this.validateWalletAddress();
+    this.validateRawRouteResult();
+
+    let tx: Transaction | null = null;
+    let inputCoin = null;
+    if (params.txExtensionParams) {
+      const { initTx, coinIn } = params.txExtensionParams;
+      tx = initTx;
+      inputCoin = coinIn;
+    } else {
+      tx = new Transaction();
+      tx.setSender(this.walletAddress);
+
+      inputCoin = await this.selectCoinInForSwap(
+        tx,
+        BigInt(this.rawRouteResult.swapAmountWithDecimal),
+        this.rawRouteResult.tokenIn
+      );
+    }
+
+    const { tx: nextTx, coinOut } = await buildTx({
+      quoteResponse: this.rawRouteResult,
+      slippage: this.calcSlippage(params.slippage),
+      commission: this.commission,
+      accountAddress: this.walletAddress,
+      extendTx: {
+        tx,
+        coinIn: inputCoin,
+      },
+    });
+
+    if (!coinOut) {
+      throw new Error(`${this.name} build swap transaction failed`);
+    }
+
+    return {
+      tx: 'txBytes' in nextTx ? Transaction.from(nextTx.txBytes) : nextTx,
+      coinOut,
+    };
+  }
+}

package/src/sdk/aftermath.ts

@@ -0,0 +1,132 @@
+import { Transaction } from '@scallop-io/sui-kit';
+import {
+  RouterProtocolName,
+  RouterCompleteTradeRoute,
+  ApiRouterPartialCompleteTradeRouteBody,
+  Aftermath,
+  ConfigAddresses,
+  AftermathApi,
+} from 'aftermath-ts-sdk';
+import { SwapSdkBase } from 'src/class';
+import { afConfigAddresses } from 'src/const/afAddresses';
+import { BigNumber } from 'bignumber.js';
+import {
+  FetchRouteParams,
+  FetchRouteResult,
+  SwapParams,
+  SwapSdkConstructorParams,
+} from 'src/interface';
+
+export class AftermathSwap extends SwapSdkBase<
+  RouterProtocolName,
+  RouterCompleteTradeRoute,
+  ApiRouterPartialCompleteTradeRouteBody
+> {
+  readonly afClient: Aftermath;
+  readonly afApi: AftermathApi;
+  constructor(
+    params: SwapSdkConstructorParams & {
+      addresses?: ConfigAddresses;
+    }
+  ) {
+    super('aftermath', params);
+    this.afApi = new AftermathApi(
+      this.client,
+      params.addresses ?? afConfigAddresses
+    );
+    this.afClient = new Aftermath('MAINNET', this.afApi);
+  }
+
+  get router() {
+    return this.afClient.Router();
+  }
+
+  setFetchRouteSettings(
+    settings: ApiRouterPartialCompleteTradeRouteBody
+  ): void {
+    this.fetchSettings = settings;
+  }
+
+  private parseRawRouteToFormattedResult(rawRoute: RouterCompleteTradeRoute) {
+    const totalCoinInAmount = rawRoute.coinIn.amount;
+    const formattedResult = {
+      ...rawRoute,
+      name: this.name,
+    } as FetchRouteResult<any>['formattedResult'];
+    formattedResult.routes.forEach((route) => {
+      const routeCoinInAmount = route.paths[0].coinIn.amount;
+      route.splitPercentage = BigNumber(routeCoinInAmount.toString())
+        .div(totalCoinInAmount.toString())
+        .times(100)
+        .toNumber();
+    });
+    return formattedResult;
+  }
+
+  async fetchRoute(
+    params: FetchRouteParams
+  ): Promise<FetchRouteResult<RouterCompleteTradeRoute>> {
+    const normalizedParams = this.normalizeFetchRouteParams(params);
+
+    const { coinInType, coinOutType, swapAmount } = normalizedParams;
+    const rawRouteResult = await this.withTimeout(
+      this.router.getCompleteTradeRouteGivenAmountIn({
+        ...this.fetchSettings,
+        coinInType,
+        coinOutType,
+        coinInAmount: swapAmount,
+      })
+    );
+
+    if (!rawRouteResult) {
+      throw new Error(`${this.name} fetch route returned empty response`);
+    }
+
+    this.rawRouteResult = rawRouteResult;
+
+    return {
+      formattedResult: this.parseRawRouteToFormattedResult(rawRouteResult),
+      rawRouteResult,
+    };
+  }
+
+  async buildSwapTransaction(params: SwapParams) {
+    this.validateWalletAddress();
+    this.validateRawRouteResult();
+
+    let tx: Transaction | null = null;
+    let inputCoin = null;
+    if (params.txExtensionParams) {
+      const { initTx, coinIn } = params.txExtensionParams;
+      tx = initTx;
+      inputCoin = coinIn;
+    } else {
+      tx = new Transaction();
+      tx.setSender(this.walletAddress);
+
+      inputCoin = await this.selectCoinInForSwap(
+        tx,
+        this.rawRouteResult.coinIn.amount,
+        this.rawRouteResult.coinIn.type
+      );
+    }
+
+    const { tx: nextTx, coinOutId: outputCoin } =
+      await this.router.addTransactionForCompleteTradeRoute({
+        walletAddress: this.walletAddress,
+        completeRoute: this.rawRouteResult,
+        slippage: this.calcSlippage(params.slippage),
+        tx,
+        coinInId: inputCoin,
+      });
+
+    if (!outputCoin) {
+      throw new Error(`${this.name} build swap transaction failed`);
+    }
+
+    return {
+      tx: nextTx,
+      coinOut: outputCoin,
+    };
+  }
+}

package/src/sdk/cetus.ts

@@ -0,0 +1,198 @@
+import { Transaction } from '@mysten/sui/transactions';
+import {
+  AggregatorClient,
+  AggregatorClientParams,
+  ALL_DEXES,
+  Env,
+  FindRouterParams,
+  Path,
+  RouterDataV3,
+} from '@cetusprotocol/aggregator-sdk';
+import { SwapSdkBase } from 'src/class';
+import BN from 'bn.js';
+import { BigNumber } from 'bignumber.js';
+import {
+  FetchRouteParams,
+  SwapParams,
+  SwapSdkConstructorParams,
+  SwapRoute,
+  FormattedRouteResult,
+} from 'src/interface';
+import { normalizeStructTag } from '@mysten/sui/utils';
+
+type RawRouteResult = RouterDataV3;
+
+export class CetusSwap extends SwapSdkBase<
+  string,
+  RawRouteResult,
+  FindRouterParams
+> {
+  readonly cetusClient: AggregatorClient;
+  constructor(params: SwapSdkConstructorParams & AggregatorClientParams) {
+    super('cetus', params);
+    this.cetusClient = new AggregatorClient({
+      ...params,
+      endpoint:
+        params.endpoint ?? 'https://api-sui.cetus.zone/router_v3/find_routes',
+      signer: params.signer ?? this.walletAddress,
+      client: params.client ?? this.client,
+    });
+    this.cetusClient = new AggregatorClient({
+      endpoint: 'https://api-sui.cetus.zone/router_v3/find_routes',
+      signer: this.walletAddress,
+      client: this.client,
+      env: Env.Mainnet,
+    });
+    this.pools = ALL_DEXES;
+  }
+
+  private createRoute(
+    paths: Path[],
+    coinInType: string,
+    coinOutType: string
+  ): SwapRoute[] {
+    const routes: SwapRoute[] = [];
+
+    let prev = null;
+    let idx = 0;
+
+    for (const path of paths) {
+      if (path.from === coinInType) {
+        routes.push({
+          paths: [],
+          coinIn: {
+            type: path.from,
+            amount: BigInt(path.amountIn),
+          },
+          coinOut: {
+            type: path.target,
+            amount: BigInt(path.amountOut),
+          },
+        });
+        prev = path.target;
+      } else if (path.from === prev) {
+        // Get last route
+        const route = routes[idx];
+        route.paths.push({
+          protocolName: path.provider,
+          coinIn: {
+            type: path.from,
+            amount: BigInt(path.amountIn),
+          },
+          coinOut: {
+            type: path.target,
+            amount: BigInt(path.amountOut),
+          },
+        });
+      } else if (path.target === coinOutType) {
+        idx++;
+        prev = null;
+      }
+    }
+
+    const totalSwapAmount = routes
+      .reduce((acc, r) => acc + r.coinIn.amount, BigInt(0))
+      .toString();
+    routes.forEach((r) => {
+      r.splitPercentage = BigNumber(r.coinIn.amount.toString())
+        .div(totalSwapAmount)
+        .times(100)
+        .toNumber();
+    });
+    return routes;
+  }
+
+  /**
+   * Parse the raw route data from Cetus to the standardized FetchRouteResult format.
+   * @returns FormattedRouteResult
+   */
+  private parseRawToFormattedResult({
+    routerData,
+    coinInType,
+    coinOutType,
+  }: {
+    routerData: RouterDataV3;
+    coinInType: string;
+    coinOutType: string;
+  }): Omit<FormattedRouteResult, 'name'> {
+    return {
+      coinIn: {
+        type: coinInType,
+        amount: BigInt(routerData.amountIn.toString() ?? '0'),
+      },
+      coinOut: {
+        type: coinOutType,
+        amount: BigInt(routerData.amountOut.toString() ?? '0'),
+      },
+      routes: this.createRoute(routerData.paths, coinInType, coinOutType),
+    };
+  }
+
+  setFetchRouteSettings(settings: FindRouterParams) {
+    this.fetchSettings = settings;
+  }
+
+  async fetchRoute(params: FetchRouteParams) {
+    const normalizedParams = this.normalizeFetchRouteParams(params);
+    const { coinInType, coinOutType, swapAmount } = normalizedParams;
+    const rawRouteResult = await this.withTimeout(
+      this.cetusClient.findRouters({
+        from: normalizeStructTag(coinInType),
+        target: normalizeStructTag(coinOutType),
+        amount: new BN(swapAmount.toString()),
+        byAmountIn: true,
+        ...this.fetchSettings,
+      })
+    );
+
+    if (!rawRouteResult) {
+      throw new Error(`${this.name} fetch route returned empty response`);
+    }
+
+    this.rawRouteResult = rawRouteResult;
+    return {
+      formattedResult: {
+        ...this.parseRawToFormattedResult({
+          routerData: rawRouteResult,
+          coinInType: coinInType,
+          coinOutType: coinOutType,
+        }),
+        name: this.name,
+      },
+      rawRouteResult,
+    };
+  }
+
+  async buildSwapTransaction(params: SwapParams) {
+    this.validateWalletAddress();
+    this.validateRawRouteResult();
+
+    let tx: Transaction | null = null;
+    let inputCoin = null;
+    if (params.txExtensionParams) {
+      const { initTx, coinIn } = params.txExtensionParams;
+      tx = initTx;
+      inputCoin = coinIn;
+    } else {
+      tx = new Transaction();
+      tx.setSender(this.walletAddress);
+      inputCoin = await this.selectCoinInForSwap(
+        tx,
+        BigInt(this.rawRouteResult.amountIn.toString()),
+        this.rawRouteResult.paths[0].from
+      );
+    }
+
+    const outputCoin = await this.cetusClient.routerSwap({
+      router: this.rawRouteResult,
+      txb: tx,
+      slippage: this.calcSlippage(params.slippage),
+      inputCoin,
+    });
+
+    return {
+      tx,
+      coinOut: outputCoin,
+    };
+  }
+}