@scallop-io/sui-scallop-sdk 3.0.2 → 4.1.0

package/src/repositories/coinBalance/helpers.ts

@@ -0,0 +1,394 @@
+import { CoinBalanceContext } from './types.js';
+import { logError } from '../utils.js';
+import { ScallopRpcError, ScallopParseError } from 'src/errors/index.js';
+import { normalizeStructTag } from '@mysten/sui/utils';
+import { SuiClientTypes } from '@mysten/sui/client';
+import { queryKeys } from 'src/constants/queryKeys.js';
+import type { QueryClient } from '@tanstack/query-core';
+import { getSharedObjectData } from 'src/utils/object.js';
+import { SuiTxBlock } from '@scallop-io/sui-kit';
+import { bcs } from '@mysten/sui/bcs';
+import { BigNumber } from 'bignumber.js';
+
+const getUserBalanceFromOnChain = async (
+  ctx: Pick<CoinBalanceContext, 'onchain'>,
+  { address, coinType }: { address: string; coinType: string }
+) => {
+  const { onchain } = ctx;
+  const result = await onchain.client.getBalance({
+    owner: address,
+    coinType,
+  });
+
+  return result.balance;
+};
+
+const updateCachedBalance = (
+  queryClient: QueryClient,
+  {
+    balance,
+    coinType,
+    address,
+    node,
+  }: {
+    balance: SuiClientTypes.Balance;
+    coinType: string;
+    address: string;
+    node: string;
+  }
+) => {
+  const key = queryKeys.rpc.getCoinBalance({
+    node,
+    address,
+    coinType,
+  });
+
+  queryClient.setQueryData<SuiClientTypes.Balance>(key, balance, {
+    updatedAt: Date.now(),
+  });
+};
+
+const getUserBalancesFromOnChain = async (
+  ctx: Pick<CoinBalanceContext, 'onchain'> & {
+    queryClient: QueryClient;
+  },
+  address: string
+) => {
+  const { onchain, queryClient } = ctx;
+  const allBalances: SuiClientTypes.Balance[] = [];
+  let cursor: string | null = null;
+  let hasNextPage = true;
+
+  while (hasNextPage) {
+    const result = await onchain.client.listBalances({
+      owner: address,
+      cursor,
+      limit: 50,
+    });
+    allBalances.push(...(result.balances ?? []));
+    hasNextPage = result.hasNextPage;
+    cursor = result.cursor;
+  }
+
+  if (!allBalances.length) return {};
+
+  const balances = allBalances.reduce(
+    (acc, curr) => {
+      if (curr.balance !== '0') {
+        const coinType = normalizeStructTag(curr.coinType);
+        acc[coinType] = curr;
+        updateCachedBalance(queryClient, {
+          balance: curr,
+          coinType,
+          address,
+          node: onchain.url,
+        });
+      }
+      return acc;
+    },
+    {} as Record<string, SuiClientTypes.Balance>
+  );
+
+  return balances;
+};
+
+export const getCoinAmountsFromOnChain = async (
+  ctx: Pick<
+    CoinBalanceContext,
+    'onchain' | 'fetchWithCache' | 'metadata' | 'queryClient'
+  >,
+  readArgs: {
+    coinNames?: string[];
+    address: string;
+  }
+) => {
+  const { fetchWithCache, onchain, metadata, queryClient } = ctx;
+  const { address, coinNames = [...metadata.whitelist.lending.values()] } =
+    readArgs;
+
+  const balances = await fetchWithCache({
+    queryKey: queryKeys.rpc.getAllCoinBalances({
+      node: onchain.url,
+      activeAddress: address,
+    }),
+    queryFn: () =>
+      getUserBalancesFromOnChain({ onchain, queryClient }, address),
+  });
+
+  // Dense map: every requested coin is present, defaulting to 0 (matches the
+  // legacy getCoinAmounts contract — number values, no dropped keys).
+  const filteredBalances = coinNames.reduce(
+    (acc, coinName) => {
+      const coinType = metadata.parseCoinType(coinName);
+      acc[coinName] = coinType ? Number(balances[coinType]?.balance ?? 0) : 0;
+      return acc;
+    },
+    {} as Record<string, number>
+  );
+
+  return filteredBalances;
+};
+
+export const getCoinAmountFromOnChain = async (
+  ctx: Pick<CoinBalanceContext, 'onchain' | 'fetchWithCache' | 'metadata'>,
+  readArgs: {
+    coinName: string;
+    address: string;
+  }
+): Promise<number> => {
+  const { fetchWithCache, onchain, metadata } = ctx;
+  const { address, coinName } = readArgs;
+
+  const coinType = metadata.parseCoinType(coinName);
+  if (!coinType) return 0;
+
+  const balance = await fetchWithCache({
+    queryKey: queryKeys.rpc.getCoinBalance({
+      node: onchain.url,
+      address,
+      coinType,
+    }),
+    queryFn: () =>
+      getUserBalanceFromOnChain({ onchain }, { address, coinType }),
+  });
+
+  return Number(balance?.balance ?? 0);
+};
+
+export const getSCoinAmountsFromOnChain = async (
+  ctx: Pick<
+    CoinBalanceContext,
+    'onchain' | 'fetchWithCache' | 'metadata' | 'queryClient'
+  >,
+  readArgs: {
+    sCoinNames?: string[];
+    address: string;
+  }
+) => {
+  const { fetchWithCache, onchain, metadata, queryClient } = ctx;
+  const { address, sCoinNames = [...metadata.whitelist.scoin.values()] } =
+    readArgs;
+
+  const balances = await fetchWithCache({
+    queryKey: queryKeys.rpc.getAllCoinBalances({
+      node: onchain.url,
+      activeAddress: address,
+    }),
+    queryFn: () =>
+      getUserBalancesFromOnChain({ onchain, queryClient }, address),
+  });
+
+  const filteredBalances = sCoinNames.reduce(
+    (acc, coinName) => {
+      const sCoinType = metadata.parseSCoinType(coinName);
+      acc[coinName] = sCoinType ? Number(balances[sCoinType]?.balance ?? 0) : 0;
+      return acc;
+    },
+    {} as Record<string, number>
+  );
+
+  return filteredBalances;
+};
+
+export const getSCoinAmountFromOnChain = async (
+  ctx: Pick<CoinBalanceContext, 'onchain' | 'fetchWithCache' | 'metadata'>,
+  readArgs: {
+    sCoinName: string;
+    address: string;
+  }
+) => {
+  const { fetchWithCache, onchain, metadata } = ctx;
+  const { address, sCoinName } = readArgs;
+
+  const sCoinType = metadata.parseSCoinType(sCoinName);
+  if (!sCoinType) return 0;
+
+  const balance = await fetchWithCache({
+    queryKey: queryKeys.rpc.getCoinBalance({
+      node: onchain.url,
+      address,
+      coinType: sCoinType,
+    }),
+    queryFn: () =>
+      getUserBalanceFromOnChain({ onchain }, { address, coinType: sCoinType }),
+  });
+
+  return Number(balance?.balance ?? 0);
+};
+
+export const getMarketCoinAmountsFromOnChain = async (
+  ctx: Pick<
+    CoinBalanceContext,
+    'onchain' | 'fetchWithCache' | 'metadata' | 'queryClient'
+  >,
+  readArgs: {
+    marketCoinNames?: string[];
+    address: string;
+  }
+) => {
+  const { fetchWithCache, onchain, metadata, queryClient } = ctx;
+  const { address, marketCoinNames = [...metadata.whitelist.scoin.values()] } =
+    readArgs;
+
+  const balances = await fetchWithCache({
+    queryKey: queryKeys.rpc.getAllCoinBalances({
+      node: onchain.url,
+      activeAddress: address,
+    }),
+    queryFn: () =>
+      getUserBalancesFromOnChain({ onchain, queryClient }, address),
+  });
+
+  const filteredBalances = marketCoinNames.reduce(
+    (acc, coinName) => {
+      const marketCoinType = metadata.parseMarketCoinType(coinName);
+      acc[coinName] = marketCoinType
+        ? Number(balances[marketCoinType]?.balance ?? 0)
+        : 0;
+      return acc;
+    },
+    {} as Record<string, number>
+  );
+
+  return filteredBalances;
+};
+
+export const getMarketCoinAmountFromOnChain = async (
+  ctx: Pick<CoinBalanceContext, 'onchain' | 'fetchWithCache' | 'metadata'>,
+  readArgs: {
+    marketCoinName: string;
+    address: string;
+  }
+) => {
+  const { fetchWithCache, onchain, metadata } = ctx;
+  const { address, marketCoinName } = readArgs;
+
+  const marketCoinType = metadata.parseMarketCoinType(marketCoinName);
+  if (!marketCoinType) return 0;
+
+  const balance = await fetchWithCache({
+    queryKey: queryKeys.rpc.getCoinBalance({
+      node: onchain.url,
+      address,
+      coinType: marketCoinType,
+    }),
+    queryFn: () =>
+      getUserBalanceFromOnChain(
+        { onchain },
+        { address, coinType: marketCoinType }
+      ),
+  });
+
+  return Number(balance?.balance ?? 0);
+};
+
+export const querySCoinTotalSupplyFromOnChain = async (
+  ctx: Pick<
+    CoinBalanceContext,
+    'onchain' | 'fetchWithCache' | 'metadata' | 'logger'
+  >,
+  sCoinName: string
+) => {
+  const { onchain, metadata, fetchWithCache } = ctx;
+  const {
+    getCoinDecimal,
+    parseSCoinType,
+    parseUnderlyingSCoinType,
+    parseCoinName,
+    addresses: { scoin },
+  } = metadata;
+
+  const queryTarget = `${scoin.id}::s_coin_converter::total_supply`;
+  const treasury = scoin.coins[sCoinName]?.treasury;
+  if (!treasury) {
+    throw logError(
+      ctx.logger,
+      new ScallopParseError(
+        `Treasury address not found for sCoin: ${sCoinName}`,
+        {
+          context: { sCoinName },
+        }
+      )
+    );
+  }
+
+  const tx = new SuiTxBlock();
+  const treasuryObject = await fetchWithCache({
+    queryKey: queryKeys.rpc.getSharedObject({
+      objectId: treasury,
+      node: onchain.url,
+    }),
+    queryFn: () => onchain.getObject({ objectId: treasury }),
+  });
+  if (!treasuryObject.object) {
+    throw logError(
+      ctx.logger,
+      new ScallopRpcError(`Failed to fetch treasury object ${treasury}`, {
+        context: { treasury },
+      })
+    );
+  }
+  const args = [
+    await getSharedObjectData(
+      { onchain, fetchWithCache },
+      {
+        tx,
+        objectId: treasuryObject.object,
+      }
+    ),
+  ];
+  const typeArgs = [
+    parseSCoinType(sCoinName),
+    parseUnderlyingSCoinType(sCoinName),
+  ].filter((t): t is string => !!t);
+  tx.moveCall(queryTarget, args, typeArgs);
+
+  const include: Omit<
+    SuiClientTypes.SimulateTransactionOptions<{
+      commandResults: true;
+    }>,
+    'transaction'
+  > = {
+    include: {
+      commandResults: true,
+    },
+  };
+
+  const queryResults = await fetchWithCache({
+    queryKey: queryKeys.rpc.getInspectTxn({
+      queryTarget,
+      args,
+      typeArgs,
+      node: onchain.url,
+      ...include,
+    }),
+    queryFn: () =>
+      onchain.client.simulateTransaction<{ commandResults: true }>({
+        ...include,
+        transaction: tx.txBlock,
+      }),
+  });
+
+  const commandResults = queryResults?.commandResults;
+  if (!commandResults) {
+    throw logError(
+      ctx.logger,
+      new ScallopRpcError(
+        `Failed to query total supply for ${sCoinName}: ${queryResults[queryResults.$kind]?.status.error?.message}`,
+        { context: { sCoinName } }
+      )
+    );
+  }
+
+  if (
+    commandResults &&
+    commandResults[0]?.returnValues &&
+    commandResults[0].returnValues[0]
+  ) {
+    const value = commandResults[0].returnValues[0].bcs;
+    const decimal = getCoinDecimal(parseCoinName(sCoinName) ?? '') ?? 0;
+    return BigNumber(bcs.u64().parse(value)).shiftedBy(-decimal).toNumber();
+  }
+
+  return 0;
+};

package/src/repositories/coinBalance/index.ts

@@ -0,0 +1,69 @@
+/**
+ * coin balance by address
+ * total supply of scoin
+ */
+
+import { BaseRepository } from '../base.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+import {
+  getCoinAmountFromOnChain,
+  getCoinAmountsFromOnChain,
+  getMarketCoinAmountFromOnChain,
+  getMarketCoinAmountsFromOnChain,
+  getSCoinAmountFromOnChain,
+  getSCoinAmountsFromOnChain,
+  querySCoinTotalSupplyFromOnChain,
+} from './helpers.js';
+import {
+  CoinBalanceContext,
+  CoinBalanceMetadata,
+  CoinBalanceRepoParams,
+} from './types.js';
+
+export class CoinBalanceRepository extends BaseRepository<
+  CoinBalanceContext,
+  CoinBalanceMetadata
+> {
+  private readonly onchain: OnChainDataSource;
+
+  constructor({ onchain, ...params }: CoinBalanceRepoParams) {
+    super(params);
+    this.onchain = onchain;
+  }
+
+  get context() {
+    return {
+      ...this.baseContext,
+      onchain: this.onchain,
+      queryClient: this.queryClient,
+    };
+  }
+
+  getCoinAmounts(args: { coinNames?: string[]; address: string }) {
+    return getCoinAmountsFromOnChain(this.context, args);
+  }
+
+  getCoinAmount(args: { coinName: string; address: string }) {
+    return getCoinAmountFromOnChain(this.context, args);
+  }
+
+  getSCoinAmounts(args: { sCoinNames?: string[]; address: string }) {
+    return getSCoinAmountsFromOnChain(this.context, args);
+  }
+
+  getSCoinAmount(args: { sCoinName: string; address: string }) {
+    return getSCoinAmountFromOnChain(this.context, args);
+  }
+
+  getSCoinTotalSupply(sCoinName: string) {
+    return querySCoinTotalSupplyFromOnChain(this.context, sCoinName);
+  }
+
+  getMarketCoinAmounts(args: { marketCoinNames?: string[]; address: string }) {
+    return getMarketCoinAmountsFromOnChain(this.context, args);
+  }
+
+  getMarketCoinAmount(args: { marketCoinName: string; address: string }) {
+    return getMarketCoinAmountFromOnChain(this.context, args);
+  }
+}

package/src/repositories/coinBalance/types.ts

@@ -0,0 +1,33 @@
+import type { QueryClient } from '@tanstack/query-core';
+import { BaseContext, BaseRepoParams } from '../types.js';
+import { AddressesInterface } from 'src/types/address.js';
+import { OnChainDataSource } from 'src/datasources/onchain.js';
+
+export type CoinBalanceMetadata = {
+  whitelist: {
+    lending: ReadonlySet<string>;
+    scoin: ReadonlySet<string>;
+  };
+  addresses: {
+    scoin: AddressesInterface['scoin'];
+  };
+  parseCoinType: (coinName: string) => string | undefined;
+  parseSCoinType: (sCoinName: string) => string | undefined;
+  parseMarketCoinType: (coinName: string) => string | undefined;
+  parseSCoinNameFromType: (sCoinType: string) => string | undefined;
+  parseUnderlyingSCoinType: (sCoinName: string) => string | undefined;
+  getSCoinTreasury: (sCoinName: string) => string | undefined;
+  getCoinDecimal: (coinName: string) => number | undefined;
+  parseCoinName: (marketCoinName: string) => string | undefined;
+};
+
+export type CoinBalanceContext = BaseContext & {
+  onchain: OnChainDataSource;
+  queryClient: QueryClient;
+  metadata: CoinBalanceMetadata;
+};
+
+export type CoinBalanceRepoParams = BaseRepoParams & {
+  onchain: OnChainDataSource;
+  metadata: CoinBalanceMetadata;
+};

package/src/repositories/flashloan/const.ts

@@ -0,0 +1,3 @@
+export const FEE_DENOMINATOR = 1e4;
+export const FLASHLOAN_FEES_TABLE_ID =
+  '0x00481a93b819d744a7d79ecdc6c62c74f2f7cb4779316c4df640415817ac61bb' as const;

package/src/repositories/flashloan/helpers.ts

@@ -0,0 +1,107 @@
+import { SuiClientTypes } from '@mysten/sui/client';
+import { queryKeys } from 'src/constants/queryKeys.js';
+import { SuiObjectData } from 'src/types/sui.js';
+import { getDfObjectIdAndName, parseObjectAs } from 'src/utils/object.js';
+import { FlashloanRepoContext } from './types.js';
+import type { OnChainReadContext } from '../utils.js';
+import { bcs } from '@mysten/sui/bcs';
+import { FEE_DENOMINATOR, FLASHLOAN_FEES_TABLE_ID } from './const.js';
+
+const queryFlashloanFees = async (
+  ctx: OnChainReadContext,
+  {
+    assetTypeMap,
+  }: {
+    assetTypeMap: Record<string, string>;
+  }
+) => {
+  const { onchain, fetchWithCache } = ctx;
+
+  let cursor: string | null | undefined = null;
+  let nextPage: boolean = false;
+  const ids: string[] = [];
+
+  do {
+    const inputs: SuiClientTypes.ListDynamicFieldsOptions = {
+      parentId: FLASHLOAN_FEES_TABLE_ID,
+      limit: 50,
+      cursor,
+    };
+    const resp = await fetchWithCache({
+      queryKey: queryKeys.rpc.getDynamicFields(inputs),
+      queryFn: () => onchain.client.listDynamicFields(inputs),
+    });
+
+    if (!resp) break;
+
+    // get the dynamic object ids
+    const dynamicFieldObjectIds = resp.dynamicFields
+      .filter((field) => {
+        const assetType = `0x${bcs.string().parse(field.name.bcs)}`;
+        return !!assetTypeMap[assetType];
+      })
+      .map((field) => field.fieldId);
+
+    ids.push(...dynamicFieldObjectIds);
+    nextPage = resp.hasNextPage;
+    cursor = resp.cursor;
+  } while (nextPage);
+
+  if (ids.length === 0) {
+    return [];
+  }
+
+  // fetch the dynamic objects in batch
+  const include = {
+    json: true,
+  };
+
+  const { objects: flashloanFeeObjects } = await fetchWithCache({
+    queryKey: queryKeys.rpc.getObjects({
+      node: onchain.url,
+      objectIds: ids,
+    }),
+    queryFn: () =>
+      onchain.client.getObjects({
+        objectIds: ids,
+        include,
+      }),
+  });
+
+  return flashloanFeeObjects;
+};
+
+export const getFlashloanFeesFromOnChain = async (
+  ctx: FlashloanRepoContext,
+  { assetNames }: { assetNames: string[] }
+) => {
+  const { metadata } = ctx;
+  const assetNamesSet = new Set(assetNames);
+  const assetTypeMap = Object.fromEntries(
+    [...metadata.coinTypeToCoinNameMap.entries()].filter(([, coinName]) =>
+      assetNamesSet.has(coinName)
+    )
+  );
+
+  const flashloanFeeObjects = await queryFlashloanFees(ctx, {
+    assetTypeMap,
+  });
+
+  return flashloanFeeObjects
+    .filter((object): object is SuiObjectData => !(object instanceof Error))
+    .reduce(
+      (prev, curr) => {
+        if (curr) {
+          const { name } = getDfObjectIdAndName(curr);
+          const assetType = `0x${name}`;
+          const assetName = assetTypeMap[assetType];
+          if (!assetName) return prev;
+
+          const feeNumerator = +parseObjectAs<string>(curr);
+          prev[assetName] = feeNumerator / FEE_DENOMINATOR;
+        }
+        return prev;
+      },
+      {} as Record<string, number>
+    );
+};

package/src/repositories/flashloan/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Flashloan Fees
+ */
+
+import { BaseRepository } from '../base.js';
+import { OnChainDataSource } from '../../datasources/onchain.js';
+import { getFlashloanFeesFromOnChain } from './helpers.js';
+import {
+  FlashloanMetadata,
+  FlashloanRepoParams,
+  FlashloanRepoContext,
+} from './types.js';
+
+export class FlashloanRepository extends BaseRepository<
+  FlashloanRepoContext,
+  FlashloanMetadata
+> {
+  private readonly onchain: OnChainDataSource;
+
+  constructor({ onchain, ...params }: FlashloanRepoParams) {
+    super(params);
+    this.onchain = onchain;
+  }
+
+  get context() {
+    return { ...this.baseContext, onchain: this.onchain };
+  }
+
+  getFlashloanFees(assetNames: string[]) {
+    return getFlashloanFeesFromOnChain(this.context, {
+      assetNames,
+    });
+  }
+}

package/src/repositories/flashloan/types.ts

@@ -0,0 +1,16 @@
+import { BaseContext, BaseRepoParams } from '../types.js';
+import { OnChainDataSource } from '../../datasources/onchain.js';
+
+export type FlashloanRepoContext = BaseContext & {
+  onchain: OnChainDataSource;
+  metadata: FlashloanMetadata;
+};
+
+export type FlashloanRepoParams = BaseRepoParams & {
+  onchain: OnChainDataSource;
+  metadata: FlashloanMetadata;
+};
+
+export type FlashloanMetadata = {
+  coinTypeToCoinNameMap: ReadonlyMap<string, string>;
+};

package/src/repositories/isolatedAssets/bcs.ts

@@ -0,0 +1,4 @@
+import { bcs } from '@mysten/sui/bcs';
+
+export const IsolatedAssetBcs = bcs.bool();
+export const IsolatedAssetTypeBcs = bcs.string();

package/src/repositories/isolatedAssets/const.ts

@@ -0,0 +1,2 @@
+export const ISOLATED_ASSET_KEY_TYPE = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::IsolatedAssetKey`; // prod
+// const isolatedAssetKeyType = `0x6c23585e940a989588432509107e98bae06dbca4e333f26d0635d401b3c7c76d::market_dynamic_keys::IsolatedAssetKey`;