@scallop-io/scallop-swap-sdk 1.0.0

package/src/sdk/flowx.ts

@@ -0,0 +1,176 @@
+import {
+  AggregatorQuoter,
+  Coin,
+  Commission,
+  GetRoutesResult,
+  Protocol,
+  SingleQuoteQueryParams,
+  TradeBuilder,
+} from '@flowx-finance/sdk';
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from '@mysten/sui/transactions';
+import { normalizeStructTag } from '@mysten/sui/utils';
+import { SwapSdkBase } from 'src/class';
+import {
+  FetchRouteParams,
+  FetchRouteResult,
+  FormattedRouteResult,
+  SwapParams,
+  SwapRoute,
+  SwapSdkConstructorParams,
+} from 'src/interface';
+import { transformProperCase } from 'src/utils';
+
+export class FlowXSwap extends SwapSdkBase<
+  Protocol,
+  GetRoutesResult<Coin, Coin>,
+  Omit<SingleQuoteQueryParams, 'amountIn' | 'tokenIn' | 'tokenOut'>
+> {
+  private quoter: AggregatorQuoter = new AggregatorQuoter('mainnet');
+  commission?: Commission;
+
+  constructor(
+    params: SwapSdkConstructorParams &
+      Omit<SingleQuoteQueryParams, 'amountIn' | 'tokenIn' | 'tokenOut'> & {
+        commission?: Commission;
+      }
+  ) {
+    super('flowx', params);
+    this.commission = params.commission;
+  }
+
+  setFetchRouteSettings(
+    settings: Omit<SingleQuoteQueryParams, 'amountIn'>
+  ): void {
+    this.fetchSettings = settings;
+  }
+
+  calcSlippage(slippageInBps: number): number {
+    return slippageInBps * 100;
+  }
+
+  protected parseRawRouteToFormattedResult(
+    rawRouteResult: GetRoutesResult<Coin, Coin>
+  ): FormattedRouteResult {
+    const routes: SwapRoute[] = [];
+    for (const smartPath of rawRouteResult.routes) {
+      routes.push({
+        paths: smartPath.paths.map((path) => ({
+          protocolName: transformProperCase(
+            (path.protocol()?.toLowerCase() ?? '') as Lowercase<string>
+          ),
+          coinIn: {
+            amount: BigInt((path.amountIn ?? 0).toString()),
+            type: path.input.coinType,
+          },
+          coinOut: {
+            amount: BigInt((path.amountOut ?? 0).toString()),
+            type: path.output.coinType,
+          },
+        })),
+        splitPercentage:
+          (Number(smartPath.amountIn ?? 0) /
+            Number(this.rawRouteResult?.amountIn ?? 1)) *
+          100,
+        coinIn: {
+          amount: BigInt(smartPath.amountIn.toString()),
+          type: normalizeStructTag(smartPath.input.coinType),
+        },
+        coinOut: {
+          amount: BigInt(smartPath.amountOut.toString()),
+          type: normalizeStructTag(smartPath.output.coinType),
+        },
+      });
+    }
+
+    return {
+      routes,
+      coinIn: {
+        type: normalizeStructTag(rawRouteResult.coinIn.coinType),
+        amount: BigInt(rawRouteResult.amountIn.toString()),
+      },
+      coinOut: {
+        type: normalizeStructTag(rawRouteResult.coinOut.coinType),
+        amount: BigInt(rawRouteResult.amountOut.toString()),
+      },
+      name: this.name,
+    };
+  }
+
+  async fetchRoute(
+    params: FetchRouteParams
+  ): Promise<FetchRouteResult<GetRoutesResult<Coin, Coin>>> {
+    const normalizedParams = this.normalizeFetchRouteParams(params);
+
+    const { coinInType, coinOutType, swapAmount } = normalizedParams;
+    const rawRouteResult = await this.withTimeout(
+      this.quoter.getRoutes({
+        ...this.fetchSettings,
+        tokenIn: coinInType,
+        tokenOut: coinOutType,
+        amountIn: swapAmount.toString(),
+        commission: this.commission,
+      })
+    );
+
+    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.amountIn.toString()),
+        this.rawRouteResult.coinIn.coinType
+      );
+    }
+
+    const tradeBuilder = new TradeBuilder('mainnet', this.rawRouteResult.routes)
+      .sender(this.walletAddress)
+      .slippage(this.calcSlippage(params.slippage))
+      .deadline(Date.now() + 60 * 60 * 1000); // one minute;
+
+    const trade = this.commission
+      ? tradeBuilder.commission(this.commission).build()
+      : tradeBuilder.build();
+
+    const coinOut = await trade.swap({
+      client: this.client,
+      tx: tx,
+      coinIn: inputCoin,
+    });
+
+    if (!coinOut) {
+      throw new Error(`${this.name} build swap transaction failed`);
+    }
+
+    return {
+      tx,
+      coinOut,
+    };
+  }
+}

package/src/sdk/index.ts

@@ -0,0 +1,4 @@
+export * from './cetus';
+export * from './aftermath';
+export * from './7k';
+export * from './flowx';

package/src/utils.ts

@@ -0,0 +1,114 @@
+import { CoinStruct, SuiClient } from '@mysten/sui/client';
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from '@mysten/sui/transactions';
+import { normalizeStructTag, SUI_TYPE_ARG } from '@mysten/sui/utils';
+import { BigNumber } from 'bignumber.js';
+
+// const DEFAULT_OBJECT_LIMIT = Number.MAX_SAFE_INTEGER;
+const SUI_TYPE = normalizeStructTag(SUI_TYPE_ARG);
+
+export const isSuiType = (coinType: string): boolean => {
+  return normalizeStructTag(coinType) === SUI_TYPE;
+};
+
+export const selectCoins = async (
+  client: SuiClient,
+  coinType: string,
+  amount: string,
+  owner: string
+) => {
+  const coins = [];
+  let targetAmount = BigNumber(amount);
+
+  try {
+    let cursor = null;
+    do {
+      const { data, hasNextPage, nextCursor } = await client.getCoins({
+        coinType,
+        owner,
+        limit: 50,
+      });
+
+      coins.push(...data);
+      targetAmount = targetAmount.minus(
+        data.reduce(
+          (acc, coin: CoinStruct) => acc.plus(BigNumber(coin.balance)),
+          BigNumber(0)
+        )
+      );
+
+      if (targetAmount.lte(0)) {
+        break;
+      }
+      cursor = nextCursor;
+      if (!hasNextPage) {
+        break;
+      }
+    } while (cursor);
+  } catch (e) {
+    console.error(e);
+  }
+
+  if (coins.length === 0) {
+    throw new Error(
+      `No available coin for type ${coinType} found in wallet ${owner}`
+    );
+  }
+
+  if (targetAmount.gt(0)) {
+    throw new Error(
+      `Insufficient balance for coin type ${coinType} in wallet ${owner}`
+    );
+  }
+
+  return coins;
+};
+
+export const mergeWithExistingOrTransfer = async (
+  tx: Transaction,
+  coin: TransactionObjectArgument,
+  client: SuiClient,
+  coinType: string,
+  sender: string
+) => {
+  try {
+    if (isSuiType(coinType)) {
+      // For SUI, merge the destObject to the gas coin
+      tx.mergeCoins(tx.gas, [coin]);
+    } else {
+      const { data } = await client.getCoins({
+        coinType,
+        owner: sender,
+        limit: 1,
+      });
+      const existingCoins = data[0];
+
+      if (!existingCoins) {
+        throw new Error('No coins available to merge with');
+      }
+
+      tx.mergeCoins(
+        tx.objectRef({
+          objectId: existingCoins.coinObjectId,
+          version: existingCoins.version,
+          digest: existingCoins.digest,
+        }),
+        [coin]
+      );
+    }
+  } catch (e: any) {
+    console.warn(e);
+    tx.transferObjects([coin], tx.pure.address(sender));
+  }
+};
+
+const parseProperCase = (str: string): string => {
+  return str[0].toUpperCase() + str.slice(1);
+};
+
+export const transformProperCase = (provider: Lowercase<string>): string => {
+  const splitted = provider.split('_');
+  return splitted.map(parseProperCase).join(' ');
+};