@scallop-io/sui-scallop-sdk 0.37.3

package/dist/txBuilders/coin.d.ts

@@ -0,0 +1,67 @@
+import { SuiTxBlock } from '@scallop-io/sui-kit';
+import { ScallopAddress, ScallopUtils } from '../models';
+import { SupportCoins } from '../types';
+export declare const selectCoin: (txBlock: SuiTxBlock, scallopAddress: ScallopAddress, scallopUtils: ScallopUtils, coinName: SupportCoins, amount: number, sender: string) => Promise<{
+    takeCoin: {
+        kind: "Input";
+        index: number;
+        type?: "object" | "pure" | undefined;
+        value?: any;
+    } | {
+        kind: "GasCoin";
+    } | {
+        kind: "Result";
+        index: number;
+    } | {
+        kind: "NestedResult";
+        index: number;
+        resultIndex: number;
+    };
+    leftCoin: {
+        kind: "Input";
+        index: number;
+        type?: "object" | "pure" | undefined;
+        value?: any;
+    } | {
+        kind: "GasCoin";
+    } | {
+        kind: "Result";
+        index: number;
+    } | {
+        kind: "NestedResult";
+        index: number;
+        resultIndex: number;
+    };
+}>;
+export declare const selectMarketCoin: (txBlock: SuiTxBlock, scallopAddress: ScallopAddress, scallopUtils: ScallopUtils, coinName: SupportCoins, amount: number, sender: string) => Promise<{
+    takeCoin: {
+        kind: "Input";
+        index: number;
+        type?: "object" | "pure" | undefined;
+        value?: any;
+    } | {
+        kind: "GasCoin";
+    } | {
+        kind: "Result";
+        index: number;
+    } | {
+        kind: "NestedResult";
+        index: number;
+        resultIndex: number;
+    };
+    leftCoin: {
+        kind: "Input";
+        index: number;
+        type?: "object" | "pure" | undefined;
+        value?: any;
+    } | {
+        kind: "GasCoin";
+    } | {
+        kind: "Result";
+        index: number;
+    } | {
+        kind: "NestedResult";
+        index: number;
+        resultIndex: number;
+    };
+}>;

package/dist/txBuilders/index.d.ts

@@ -0,0 +1 @@
+export { newScallopTxBlock } from './quickMethods';

package/dist/txBuilders/normalMethods.d.ts

@@ -0,0 +1,3 @@
+import { ScallopAddress, ScallopUtils } from '../models';
+import type { SuiTxBlockWithNormalScallopMethods } from '../types';
+export declare const newTxBlock: (scallopAddress: ScallopAddress, scallopUtils: ScallopUtils) => SuiTxBlockWithNormalScallopMethods;

package/dist/txBuilders/oracle.d.ts

@@ -0,0 +1,7 @@
+import { SuiTxBlock, SuiKit } from '@scallop-io/sui-kit';
+import { ScallopAddress, ScallopUtils } from '../models';
+import { SupportCoins, SupportAssetCoins } from '../types';
+export declare const updateOraclesForWithdrawCollateral: (txBlock: SuiTxBlock, address: ScallopAddress, scallopUtils: ScallopUtils, suiKit: SuiKit, obligationId: string, isTestnet: boolean) => Promise<void>;
+export declare const updateOraclesForLiquidation: (txBlock: SuiTxBlock, address: ScallopAddress, scallopUtils: ScallopUtils, suiKit: SuiKit, obligationId: string, isTestnet: boolean) => Promise<void>;
+export declare const updateOraclesForBorrow: (txBlock: SuiTxBlock, address: ScallopAddress, scallopUtils: ScallopUtils, suiKit: SuiKit, obligationId: string, borrowCoinName: SupportAssetCoins, isTestnet: boolean) => Promise<void>;
+export declare const updateOracles: (txBlock: SuiTxBlock, address: ScallopAddress, scallopUtils: ScallopUtils, coinNames: SupportCoins[], isTestnet: boolean) => Promise<void>;

package/dist/txBuilders/quickMethods.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file contains the complex transaction builder, which contains multiple calls in a single transaction.
+ */
+import { SuiKit } from '@scallop-io/sui-kit';
+import { ScallopAddress, ScallopUtils } from '../models';
+import type { ScallopTxBlock } from '../types';
+export declare const newScallopTxBlock: (suiKit: SuiKit, scallopAddress: ScallopAddress, scallopUtils: ScallopUtils, isTestnet: boolean) => ScallopTxBlock;

package/dist/types/data.d.ts

@@ -0,0 +1,127 @@
+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>, '.'>;
+export {};

package/dist/types/index.d.ts

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

package/dist/types/model.d.ts

@@ -0,0 +1,9 @@
+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/dist/types/txBuilder.d.ts

@@ -0,0 +1,66 @@
+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;
+    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;
+export {};

package/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "@scallop-io/sui-scallop-sdk",
+  "version": "0.37.3",
+  "description": "Tookit for interacting with Scallop on SUI",
+  "keywords": [
+    "sui",
+    "scallop labs",
+    "move",
+    "blockchain"
+  ],
+  "author": "team@scallop.io",
+  "homepage": "https://github.com/scallop-io/sui-scallop-sdk#readme",
+  "bugs": "https://github.com/scallop-io/sui-scallop-sdk/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scallop-io/sui-scallop-sdk.git"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@mysten/bcs": "^0.7.3",
+    "@mysten/sui.js": "^0.37.1",
+    "@pythnetwork/price-service-client": "^1.6.0",
+    "@scallop-io/sui-kit": "^0.37.1",
+    "axios": "^1.4.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.6.6",
+    "@commitlint/config-conventional": "^17.6.6",
+    "@commitlint/prompt-cli": "^17.6.6",
+    "@types/node": "^20.3.2",
+    "@typescript-eslint/eslint-plugin": "^5.60.1",
+    "@typescript-eslint/parser": "^5.60.1",
+    "dotenv": "^16.3.1",
+    "eslint": "^8.43.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.2.3",
+    "prettier": "^2.8.8",
+    "tsconfig-paths": "^4.2.0",
+    "tsup": "^7.1.0",
+    "typedoc": "^0.24.8",
+    "typescript": "^5.0.4",
+    "vitest": "^0.32.2"
+  },
+  "peerDependencies": {
+    "@mysten/sui.js": "^0.37.1"
+  },
+  "lint-staged": {
+    "**/*.ts": [
+      "pnpm run format:fix",
+      "pnpm run lint:fix"
+    ],
+    "**/*.json|md": [
+      "pnpm run format:fix"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "prettier": {
+    "trailingComma": "es5",
+    "tabWidth": 2,
+    "semi": true,
+    "singleQuote": true,
+    "useTabs": false,
+    "quoteProps": "as-needed",
+    "bracketSpacing": true,
+    "arrowParens": "always",
+    "endOfLine": "lf"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "browser": true,
+      "node": true,
+      "es2022": true
+    },
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:prettier/recommended"
+    ],
+    "plugins": [
+      "@typescript-eslint",
+      "prettier"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "rules": {
+      "prettier/prettier": "warn",
+      "@typescript-eslint/no-explicit-any": "off",
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_",
+          "caughtErrorsIgnorePattern": "^_"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
+    "build": "pnpm run build:types && pnpm run build:tsup",
+    "build:tsup": "tsup ./src/index.ts --format esm,cjs --sourcemap",
+    "build:types": "tsc --build",
+    "watch:tsup": "tsup ./src/index.ts --format esm,cjs --clean --splitting --watch",
+    "watch:types": "tsc --watch",
+    "watch": "pnpm run clean & pnpm run watch:types & pnpm run watch:tsup",
+    "test": "pnpm test:typecheck && pnpm test:unit",
+    "test:typecheck": "tsc -p ./test",
+    "test:unit": "vitest run --test-timeout=60000",
+    "test:watch": "vitest",
+    "format:fix": "prettier --ignore-path 'dist/* docs/*' --write '**/*.{ts,json,md}'",
+    "lint:fix": "eslint . --ignore-pattern dist --ext .ts --fix",
+    "commit": "commit",
+    "doc": "typedoc --out docs src/index.ts"
+  }
+}

package/src/constants/common.ts

@@ -0,0 +1,36 @@
+export const API_BASE_URL = 'https://sui.api.scallop.io';
+
+export const ADDRESSES_ID = '6462a088a7ace142bb6d7e9b';
+
+export const SUPPORT_ASSET_COINS = [
+  'eth',
+  'btc',
+  'usdc',
+  'usdt',
+  'sui',
+] as const;
+export const SUPPORT_COLLATERAL_COINS = [
+  'eth',
+  'btc',
+  'usdc',
+  'usdt',
+  'sui',
+] as const;
+
+export const SUPPORT_ORACLES = ['supra', 'switchboard', 'pyth'] as const;
+
+export const SUPPORT_PACKAGES = [
+  'coinDecimalsRegistry',
+  'math',
+  'whitelist',
+  'x',
+  'protocol',
+  'query',
+  'supra',
+  'pyth',
+  'switchboard',
+  'xOracle',
+  'testCoin',
+] as const;
+
+export const SUI_COIN_TYPE_ARG_REGEX = /^0x(0*)2::sui::SUI$/;

package/src/constants/index.ts

@@ -0,0 +1 @@
+export * from './common';

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './models';
+export * from './types';

package/src/models/index.ts

@@ -0,0 +1,4 @@
+export * from './scallop';
+export * from './scallopClient';
+export * from './scallopUtils';
+export * from './scallopAddress';

package/src/models/scallop.ts

@@ -0,0 +1,76 @@
+import { SuiKit } from '@scallop-io/sui-kit';
+import { ScallopAddress } from './scallopAddress';
+import { ScallopClient } from './scallopClient';
+import { ScallopUtils } from './scallopUtils';
+import { newScallopTxBlock } from '../txBuilders';
+import { ADDRESSES_ID } from '../constants';
+import type { NetworkType } from '@scallop-io/sui-kit';
+import type { ScallopParams, ScallopTxBlock } from '../types';
+
+/**
+ * ### Scallop
+ *
+ * The main instance that controls interaction with the Scallop contract.
+ *
+ * #### Usage
+ *
+ * ```typescript
+ * const sdk = new Scallop(<parameters>);
+ * ```
+ */
+export class Scallop {
+  public params: ScallopParams;
+  public suiKit: SuiKit;
+  public address: ScallopAddress;
+
+  public constructor(params: ScallopParams) {
+    this.params = params;
+    this.suiKit = new SuiKit(params);
+    this.address = new ScallopAddress({
+      id: ADDRESSES_ID,
+      network: params?.networkType,
+    });
+  }
+
+  /**
+   * Create an instance to operate the transaction block, making it more convenient to organize transaction combinations.
+   * @return Scallop Transaction Builder
+   */
+  public async createTxBuilder() {
+    await this.address.read();
+    const scallopUtils = new ScallopUtils(this.params);
+    const suiKit = new SuiKit(this.params);
+    const isTestnet = this.params.networkType === 'testnet';
+    return {
+      createTxBlock: () => {
+        return newScallopTxBlock(suiKit, this.address, scallopUtils, isTestnet);
+      },
+      signAndSendTxBlock: (txBlock: ScallopTxBlock) => {
+        return suiKit.signAndSendTxn(txBlock);
+      },
+    };
+  }
+
+  /**
+   * Create an instance to collect the addresses, making it easier to get object addresses from lending contract.
+   *
+   * @param id - The API id of the addresses.
+   * @param auth - The authentication API key.
+   * @param network - Specifies which network's addresses you want to set.
+   * @return Scallop Address
+   */
+  public createAddress(id: string, auth: string, network: NetworkType) {
+    return new ScallopAddress({ id, auth, network });
+  }
+
+  /**
+   * Create an instance that provides contract interaction operations for general users.
+   *
+   * @param walletAddress - When user cannot provide a secret key or mnemonic, the scallop client cannot directly derive the address of the transaction the user wants to sign. This argument specifies the wallet address for signing the transaction.
+   * @return Scallop Client
+   */
+  public async createScallopClient(walletAddress?: string) {
+    await this.address.read();
+    return new ScallopClient(this.params, this.address, walletAddress);
+  }
+}