@scallop-io/sui-scallop-sdk 0.37.3

package/src/txBuilders/quickMethods.ts

@@ -0,0 +1,231 @@
+/**
+ * This file contains the complex transaction builder, which contains multiple calls in a single transaction.
+ */
+import { SuiTxBlock, SuiKit } from '@scallop-io/sui-kit';
+import { ScallopAddress, ScallopUtils } from '../models';
+import { getObligations } from '../queries';
+import { newTxBlock } from './normalMethods';
+import {
+  updateOraclesForBorrow,
+  updateOraclesForWithdrawCollateral,
+  updateOracles,
+} from './oracle';
+import { selectCoin, selectMarketCoin } from './coin';
+import type { SuiTxArg } from '@scallop-io/sui-kit';
+import type { ScallopQuickMethodsHandler, ScallopTxBlock } from '../types';
+
+const requireSender = (txBlock: SuiTxBlock) => {
+  const sender = txBlock.blockData.sender;
+  if (!sender) {
+    throw new Error('Sender is required');
+  }
+  return sender;
+};
+
+const requireObligationInfo = async (
+  ...args: [
+    txBlock: SuiTxBlock,
+    scallopAddress: ScallopAddress,
+    suiKit: SuiKit,
+    obligationId?: SuiTxArg | undefined,
+    obligationKey?: SuiTxArg | undefined
+  ]
+) => {
+  const [txBlock, scallopAddress, suiKit, obligationId, obligationKey] = args;
+  if (args.length === 4 && obligationId) return { obligationId };
+  if (args.length === 5 && obligationId && obligationKey)
+    return { obligationId, obligationKey };
+  const sender = requireSender(txBlock);
+  const obligations = await getObligations(sender, scallopAddress, suiKit);
+  if (obligations.length === 0) {
+    throw new Error(`No obligation found for sender ${sender}`);
+  }
+  return {
+    obligationId: obligations[0].id,
+    obligationKey: obligations[0].keyId,
+  };
+};
+
+const scallopQuickMethodsHandler: ScallopQuickMethodsHandler = {
+  addCollateralQuick:
+    ({ txBlock, scallopAddress, scallopUtils, suiKit }) =>
+    async (amount, coinName, obligationId) => {
+      const sender = requireSender(txBlock);
+      const { obligationId: obligationArg } = await requireObligationInfo(
+        txBlock,
+        scallopAddress,
+        suiKit,
+        obligationId
+      );
+
+      if (coinName === 'sui') {
+        const [suiCoin] = txBlock.splitSUIFromGas([amount]);
+        txBlock.addCollateral(obligationArg, suiCoin, coinName);
+      } else {
+        const { leftCoin, takeCoin } = await selectCoin(
+          txBlock,
+          scallopAddress,
+          scallopUtils,
+          coinName,
+          amount,
+          sender
+        );
+        txBlock.addCollateral(obligationArg, takeCoin, coinName);
+        txBlock.transferObjects([leftCoin], sender);
+      }
+    },
+  takeCollateralQuick:
+    ({ txBlock, suiKit, scallopUtils, scallopAddress, isTestnet }) =>
+    async (amount, coinName, obligationId, obligationKey) => {
+      const { obligationId: obligationArg, obligationKey: obligationKeyArg } =
+        await requireObligationInfo(
+          txBlock,
+          scallopAddress,
+          suiKit,
+          obligationId,
+          obligationKey
+        );
+
+      await updateOraclesForWithdrawCollateral(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        suiKit,
+        obligationArg as string,
+        isTestnet
+      );
+      return txBlock.takeCollateral(
+        obligationArg,
+        obligationKeyArg as SuiTxArg,
+        amount,
+        coinName
+      );
+    },
+  depositQuick:
+    ({ txBlock, scallopUtils, scallopAddress }) =>
+    async (amount, coinName) => {
+      const sender = requireSender(txBlock);
+      if (coinName === 'sui') {
+        const [suiCoin] = txBlock.splitSUIFromGas([amount]);
+        return txBlock.deposit(suiCoin, coinName);
+      } else {
+        const { leftCoin, takeCoin } = await selectCoin(
+          txBlock,
+          scallopAddress,
+          scallopUtils,
+          coinName,
+          amount,
+          sender
+        );
+        txBlock.transferObjects([leftCoin], sender);
+        return txBlock.deposit(takeCoin, coinName);
+      }
+    },
+  withdrawQuick:
+    ({ txBlock, scallopUtils, scallopAddress }) =>
+    async (amount, coinName) => {
+      const sender = requireSender(txBlock);
+      const { leftCoin, takeCoin } = await selectMarketCoin(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        coinName,
+        amount,
+        sender
+      );
+      txBlock.transferObjects([leftCoin], sender);
+      return txBlock.withdraw(takeCoin, coinName);
+    },
+  borrowQuick:
+    ({ txBlock, suiKit, scallopUtils, scallopAddress, isTestnet }) =>
+    async (amount, coinName, obligationId, obligationKey) => {
+      const { obligationId: obligationArg, obligationKey: obligationKeyArg } =
+        await requireObligationInfo(
+          txBlock,
+          scallopAddress,
+          suiKit,
+          obligationId,
+          obligationKey
+        );
+
+      await updateOraclesForBorrow(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        suiKit,
+        obligationArg as string,
+        coinName,
+        isTestnet
+      );
+      return txBlock.borrow(
+        obligationArg,
+        obligationKeyArg as SuiTxArg,
+        amount,
+        coinName
+      );
+    },
+  repayQuick:
+    ({ txBlock, suiKit, scallopUtils, scallopAddress }) =>
+    async (amount, coinName, obligationId) => {
+      const sender = requireSender(txBlock);
+      const { obligationId: obligationArg } = await requireObligationInfo(
+        txBlock,
+        scallopAddress,
+        suiKit,
+        obligationId
+      );
+
+      if (coinName === 'sui') {
+        const [suiCoin] = txBlock.splitSUIFromGas([amount]);
+        return txBlock.repay(obligationArg, suiCoin, coinName);
+      } else {
+        const { leftCoin, takeCoin } = await selectCoin(
+          txBlock,
+          scallopAddress,
+          scallopUtils,
+          coinName,
+          amount,
+          sender
+        );
+        txBlock.transferObjects([leftCoin], sender);
+        return txBlock.repay(obligationArg, takeCoin, coinName);
+      }
+    },
+  updateAssetPricesQuick:
+    ({ txBlock, scallopUtils, scallopAddress, isTestnet }) =>
+    async (coinNames) => {
+      return updateOracles(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        coinNames,
+        isTestnet
+      );
+    },
+};
+
+export const newScallopTxBlock = (
+  suiKit: SuiKit,
+  scallopAddress: ScallopAddress,
+  scallopUtils: ScallopUtils,
+  isTestnet: boolean
+) => {
+  const txBlock = newTxBlock(scallopAddress, scallopUtils);
+  const txBlockProxy = new Proxy(txBlock, {
+    get: (target, prop) => {
+      if (prop in scallopQuickMethodsHandler) {
+        return scallopQuickMethodsHandler[
+          prop as keyof ScallopQuickMethodsHandler
+        ]({
+          txBlock: target,
+          suiKit,
+          scallopAddress,
+          scallopUtils,
+          isTestnet,
+        });
+      }
+      return target[prop as keyof SuiTxBlock];
+    },
+  });
+  return txBlockProxy as ScallopTxBlock;
+};

package/src/types/data.ts

@@ -0,0 +1,170 @@
+import {
+  SUPPORT_ASSET_COINS,
+  SUPPORT_COLLATERAL_COINS,
+  SUPPORT_ORACLES,
+  SUPPORT_PACKAGES,
+} from '../constants/common';
+
+export type SupportAssetCoins = (typeof SUPPORT_ASSET_COINS)[number];
+export type SupportCollateralCoins = (typeof SUPPORT_COLLATERAL_COINS)[number];
+export type SupportCoins = SupportAssetCoins | SupportCollateralCoins;
+export type SupportOracleType = (typeof SUPPORT_ORACLES)[number];
+export type SupportPackageType = (typeof SUPPORT_PACKAGES)[number];
+
+export interface MarketInterface {
+  collaterals: {
+    collateralFactor: {
+      value: string;
+    };
+    liquidationDiscount: {
+      value: string;
+    };
+    liquidationFactor: {
+      value: string;
+    };
+    liquidationPanelty: {
+      value: string;
+    };
+    liquidationReserveFactor: {
+      value: string;
+    };
+    maxCollateralAmount: string;
+    totalCollateralAmount: string;
+    type: {
+      name: string;
+    };
+  }[];
+  pools: {
+    baseBorrowRatePerSec: {
+      value: string;
+    };
+    borrowIndex: string;
+    cash: string;
+    debt: string;
+    highSlope: {
+      value: string;
+    };
+    interestRate: {
+      value: string;
+    };
+    kink: {
+      value: string;
+    };
+    lastUpdated: string;
+    lowSlope: {
+      value: string;
+    };
+    marketCoinSupply: string;
+    minBorrowAmount: string;
+    reserve: string;
+    reserveFactor: {
+      value: string;
+    };
+    borrowWeight: {
+      value: string;
+    };
+    type: {
+      name: string;
+    };
+  }[];
+}
+
+export interface ObligationInterface {
+  collaterals: {
+    type: {
+      name: string;
+    };
+    amount: string;
+  }[];
+  debts: {
+    type: {
+      name: string;
+    };
+    amount: string;
+    borrowIndex: string;
+  }[];
+}
+
+export interface AddressesInterface {
+  core: {
+    version: string;
+    versionCap: string;
+    market: string;
+    adminCap: string;
+    coinDecimalsRegistry: string;
+    coins: Partial<
+      Record<
+        SupportCoins,
+        {
+          id: string;
+          treasury: string;
+          metaData: string;
+          oracle: {
+            [K in SupportOracleType]: K extends (typeof SUPPORT_ORACLES)[0]
+              ? string
+              : K extends (typeof SUPPORT_ORACLES)[1]
+              ? string
+              : K extends (typeof SUPPORT_ORACLES)[2]
+              ? {
+                  feed: string;
+                  feedObject: string;
+                }
+              : never;
+          };
+        }
+      >
+    >;
+    oracles: {
+      [K in SupportOracleType]: K extends (typeof SUPPORT_ORACLES)[0]
+        ? {
+            registry: string;
+            registryCap: string;
+            holder: string;
+          }
+        : K extends (typeof SUPPORT_ORACLES)[1]
+        ? {
+            registry: string;
+            registryCap: string;
+          }
+        : K extends (typeof SUPPORT_ORACLES)[2]
+        ? {
+            registry: string;
+            registryCap: string;
+            state: string;
+            wormhole: string;
+            wormholeState: string;
+          }
+        : never;
+    } & { xOracle: string; xOracleCap: string };
+    packages: Partial<
+      Record<
+        SupportPackageType,
+        {
+          id: string;
+          upgradeCap: string;
+        }
+      >
+    >;
+  };
+}
+
+type AddressPathsProps<T> = T extends string
+  ? []
+  : {
+      [K in Extract<keyof T, string>]: [K, ...AddressPathsProps<T[K]>];
+    }[Extract<keyof T, string>];
+
+type Join<T extends string[], D extends string> = T extends []
+  ? never
+  : T extends [infer F]
+  ? F
+  : T extends [infer F, ...infer R]
+  ? F extends string
+    ? `${F}${D}${Join<Extract<R, string[]>, D>}`
+    : never
+  : string;
+
+export type AddressStringPath = Join<
+  AddressPathsProps<AddressesInterface>,
+  '.'
+>;

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './model';
+export * from './txBuilder';

package/src/types/model.ts

@@ -0,0 +1,15 @@
+import type {
+  SuiTransactionBlockResponse,
+  TransactionBlock,
+} from '@mysten/sui.js';
+import type { SuiKitParams, NetworkType } from '@scallop-io/sui-kit';
+
+export type ScallopClientFnReturnType<T extends boolean> = T extends true
+  ? SuiTransactionBlockResponse
+  : TransactionBlock;
+export type ScallopParams = {} & SuiKitParams;
+export type ScallopAddressParams = {
+  id: string;
+  auth?: string;
+  network?: NetworkType;
+};

package/src/types/txBuilder.ts

@@ -0,0 +1,136 @@
+import type { TransactionArgument } from '@mysten/sui.js';
+import type { SuiTxBlock, SuiTxArg, SuiKit } from '@scallop-io/sui-kit';
+import type { ScallopAddress, ScallopUtils } from '../models';
+import type { SupportCollateralCoins, SupportAssetCoins } from './data';
+
+type TransactionResult = TransactionArgument & TransactionArgument[];
+
+/**
+ * ========== Scallop Normal Methods ==========
+ */
+export type ScallopNormalMethods = {
+  openObligation: () => TransactionResult;
+  returnObligation: (
+    obligation: SuiTxArg,
+    obligationHotPotato: SuiTxArg
+  ) => void;
+  openObligationEntry: () => void;
+  addCollateral: (
+    obligation: SuiTxArg,
+    coin: SuiTxArg,
+    coinName: SupportCollateralCoins
+  ) => void;
+  takeCollateral: (
+    obligation: SuiTxArg,
+    obligationKey: SuiTxArg,
+    amount: number,
+    coinName: SupportCollateralCoins
+  ) => TransactionResult;
+  deposit: (coin: SuiTxArg, coinName: SupportAssetCoins) => TransactionResult;
+  depositEntry: (coin: SuiTxArg, coinName: SupportAssetCoins) => void;
+  withdraw: (
+    marketCoin: SuiTxArg,
+    coinName: SupportAssetCoins
+  ) => TransactionResult;
+  withdrawEntry: (marketCoin: SuiTxArg, coinName: SupportAssetCoins) => void;
+  borrow: (
+    obligation: SuiTxArg,
+    obligationKey: SuiTxArg,
+    amount: number,
+    coinName: SupportAssetCoins
+  ) => TransactionResult;
+  borrowEntry: (
+    obligation: SuiTxArg,
+    obligationKey: SuiTxArg,
+    amount: number,
+    coinName: SupportAssetCoins
+  ) => void;
+  repay: (
+    obligation: SuiTxArg,
+    coin: SuiTxArg,
+    coinName: SupportAssetCoins
+  ) => void;
+  borrowFlashLoan: (
+    amount: number,
+    coinName: SupportAssetCoins
+  ) => TransactionResult;
+  repayFlashLoan: (
+    coin: SuiTxArg,
+    loan: SuiTxArg,
+    coinName: SupportAssetCoins
+  ) => void;
+};
+
+export type CoreIds = {
+  protocolPkg: string;
+  market: string;
+  version: string;
+  dmlR: string; // coinDecimalsRegistry
+  oracle: string;
+};
+
+export type ScallopNormalMethodsHandler = {
+  [key in keyof ScallopNormalMethods]: (params: {
+    txBlock: SuiTxBlock;
+    coreIds: CoreIds;
+    scallopAddress: ScallopAddress;
+    scallopUtils: ScallopUtils;
+  }) => ScallopNormalMethods[key];
+};
+
+export type SuiTxBlockWithNormalScallopMethods = SuiTxBlock &
+  ScallopNormalMethods;
+
+/**
+ * ========== Scallop Quick Methods ==========
+ */
+
+export type ScallopQuickMethods = {
+  addCollateralQuick: (
+    amount: number,
+    coinName: SupportCollateralCoins,
+    obligationId?: SuiTxArg
+  ) => Promise<void>;
+  takeCollateralQuick: (
+    amount: number,
+    coinName: SupportCollateralCoins,
+    obligationId?: string,
+    obligationKey?: string
+  ) => Promise<TransactionResult>;
+  borrowQuick: (
+    amount: number,
+    coinName: SupportAssetCoins,
+    obligationId?: string,
+    obligationKey?: string
+  ) => Promise<TransactionResult>;
+  depositQuick: (
+    amount: number,
+    coinName: SupportAssetCoins
+  ) => Promise<TransactionResult>;
+  withdrawQuick: (
+    amount: number,
+    coinName: SupportAssetCoins
+  ) => Promise<TransactionResult>;
+  repayQuick: (
+    amount: number,
+    coinName: SupportAssetCoins,
+    obligationId?: string
+  ) => Promise<void>;
+  updateAssetPricesQuick: (coinNames: SupportAssetCoins[]) => Promise<void>;
+};
+
+export type ScallopQuickMethodsHandler = {
+  [key in keyof ScallopQuickMethods]: (params: {
+    txBlock: SuiTxBlockWithNormalScallopMethods;
+    suiKit: SuiKit;
+    scallopAddress: ScallopAddress;
+    scallopUtils: ScallopUtils;
+    isTestnet: boolean;
+  }) => ScallopQuickMethods[key];
+};
+
+/**
+ * ========== Scallop Tx Block ==========
+ */
+export type ScallopTxBlock = SuiTxBlockWithNormalScallopMethods &
+  ScallopQuickMethods;