@scallop-io/sui-scallop-sdk 2.0.1 → 2.0.2-switchboard-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scallop-io/sui-scallop-sdk",
-  "version": "2.0.1",
+  "version": "2.0.2-switchboard-alpha.2",
   "description": "Typescript sdk for interacting with Scallop contract on SUI",
   "keywords": [
     "sui",
@@ -44,8 +44,9 @@
     "@noble/hashes": "^1.3.2",
     "@pythnetwork/price-service-client": "^1.8.2",
     "@pythnetwork/pyth-sui-js": "2.1.0",
-    "@scallop-io/sui-kit": "1.3.1",
+    "@scallop-io/sui-kit": "1.3.5",
     "@scure/bip39": "^1.2.1",
+    "@switchboard-xyz/sui-sdk": "0.0.22-beta.1",
     "@tanstack/query-core": "5.51.15",
     "axios": "^1.6.0",
     "bech32": "^2.0.0",
@@ -82,7 +83,7 @@
   "peerDependencies": {
     "@mysten/bcs": "^1.2.0",
     "@mysten/sui": "1.3.1",
-    "@scallop-io/sui-kit": "1.3.1",
+    "@scallop-io/sui-kit": "1.3.5",
     "bn.js": "^5.2.1"
   },
   "lint-staged": {
@@ -149,6 +150,8 @@
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
     "build": "pnpm run build:tsup",
+    "build-sourcemap": "pnpm run build:sourcemap",
+    "build:sourcemap": "tsup ./src/index.ts --format esm,cjs --splitting --minify --treeshake --dts --sourcemap",
     "build:tsup": "tsup ./src/index.ts --format esm,cjs --splitting --minify --treeshake --dts",
     "watch:tsup": "tsup ./src/index.ts --format esm,cjs --clean --splitting --watch",
     "watch:types": "tsc --watch",

package/src/builders/oracles/index.ts

@@ -9,6 +9,7 @@ import type {
 } from 'src/types';
 import { xOracleList as X_ORACLE_LIST } from 'src/constants';
 import { updatePythPriceFeeds } from './pyth';
+import { updateSwitchboardAggregators } from './switchboard';
 
 /**
  * Update the price of the oracle for multiple coin.
@@ -62,7 +63,22 @@ export const updateOracles = async (
       filterAssetCoinNames(assetCoinName, 'pyth')
     );
     if (pythAssetCoinNames.length > 0)
-      await updatePythPriceFeeds(builder, assetCoinNames, txBlock);
+      await updatePythPriceFeeds(builder, pythAssetCoinNames, txBlock);
+  }
+
+  if (flattenedRules.has('switchboard')) {
+    const switchboardAssetCoinNames = assetCoinNames.filter((assetCoinName) =>
+      filterAssetCoinNames(assetCoinName, 'switchboard')
+    );
+
+    if (switchboardAssetCoinNames.length > 0) {
+      await updateSwitchboardAggregators(
+        builder,
+        switchboardAssetCoinNames,
+        txBlock,
+        builder.params.switchboardSolanaRpc
+      );
+    }
   }
 
   // Remove duplicate coin names.

package/src/builders/oracles/switchboard.ts

@@ -0,0 +1,233 @@
+import { ScallopBuilder } from 'src/models';
+import { type SuiTxBlock as SuiKitTxBlock } from '@scallop-io/sui-kit';
+import {
+  Aggregator,
+  AggregatorData,
+  ObjectParsingHelper,
+  // suiQueueCache,
+  // QueueData,
+  SwitchboardClient,
+} from '@switchboard-xyz/sui-sdk';
+import { queryMultipleObjects } from 'src/queries';
+import { SuiParsedData } from '@mysten/sui/client';
+import { toHex } from '@mysten/bcs';
+
+const getFieldsFromObject = (
+  response: SuiParsedData | null | undefined
+): any => {
+  // Check if 'data' and 'content' exist and are of the expected type
+  if (response && response.dataType === 'moveObject') {
+    // Safely return 'fields' from 'content'
+    return response.fields as any;
+  }
+
+  throw new Error('Invalid response data');
+};
+
+const parseFeedConfigs = (responses: SuiParsedData[]): AggregatorData[] => {
+  return responses.map(getFieldsFromObject).map((aggregatorData) => {
+    const currentResult = (aggregatorData.current_result as any).fields;
+    const updateState = (aggregatorData.update_state as any).fields;
+
+    // build the data object
+    const data: AggregatorData = {
+      id: ObjectParsingHelper.asId(aggregatorData.id),
+      authority: ObjectParsingHelper.asString(aggregatorData.authority),
+      createdAtMs: ObjectParsingHelper.asNumber(aggregatorData.created_at_ms),
+      currentResult: {
+        maxResult: ObjectParsingHelper.asBN(currentResult.max_result),
+        maxTimestamp: ObjectParsingHelper.asNumber(
+          currentResult.max_timestamp_ms
+        ),
+        mean: ObjectParsingHelper.asBN(currentResult.mean),
+        minResult: ObjectParsingHelper.asBN(currentResult.min_result),
+        minTimestamp: ObjectParsingHelper.asNumber(
+          currentResult.min_timestamp_ms
+        ),
+        range: ObjectParsingHelper.asBN(currentResult.range),
+        result: ObjectParsingHelper.asBN(currentResult.result),
+        stdev: ObjectParsingHelper.asBN(currentResult.stdev),
+      },
+      feedHash: toHex(
+        ObjectParsingHelper.asUint8Array(aggregatorData.feed_hash)
+      ),
+      maxStalenessSeconds: ObjectParsingHelper.asNumber(
+        aggregatorData.max_staleness_seconds
+      ),
+      maxVariance: ObjectParsingHelper.asNumber(aggregatorData.max_variance),
+      minResponses: ObjectParsingHelper.asNumber(aggregatorData.min_responses),
+      minSampleSize: ObjectParsingHelper.asNumber(
+        aggregatorData.min_sample_size
+      ),
+      name: ObjectParsingHelper.asString(aggregatorData.name),
+      queue: ObjectParsingHelper.asString(aggregatorData.queue),
+      updateState: {
+        currIdx: ObjectParsingHelper.asNumber(updateState.curr_idx),
+        results: updateState.results.map((r: any) => {
+          const oracleId = r.fields.oracle;
+          const value = ObjectParsingHelper.asBN(r.fields.result.fields);
+          const timestamp = parseInt(r.fields.timestamp_ms);
+          return {
+            oracle: oracleId,
+            value,
+            timestamp,
+          };
+        }),
+      },
+    };
+
+    return data;
+  });
+};
+
+// const parseQueueAddresses = async (
+//   cache: ScallopCache,
+//   queueAddresses: string[]
+// ): Promise<void> => {
+//   const queueParsedDatas = (
+//     await queryMultipleObjects(cache, queueAddresses)
+//   ).map((q) => getFieldsFromObject(q.content));
+
+//   // Get the existing_oracles table ids
+//   const existingOracleTableIds = queueParsedDatas.map((q: any) => {
+//     return q.existing_oracles.fields.id.id;
+//   });
+
+//   for (let i = 0; i < existingOracleTableIds.length; i++) {
+//     const parentId = existingOracleTableIds[i];
+//     const queueAddress = queueAddresses[i];
+//     const queueResponse = queueParsedDatas[i];
+//     const queueCachedData = await suiQueueCache.get(queueAddress);
+//     if (queueCachedData) {
+//       return queueCachedData;
+//     }
+
+//     let cursor = null;
+//     let nextPage = true;
+
+//     const existingOraclesIds = [];
+//     while (nextPage) {
+//       const resp = await cache.queryGetDynamicFields({
+//         parentId,
+//         limit: 25,
+//         cursor,
+//       });
+
+//       if (!resp) break;
+//       const { nextCursor, data, hasNextPage } = resp;
+//       nextPage = hasNextPage;
+//       cursor = nextCursor;
+
+//       existingOraclesIds.push(...data.map((t) => t.objectId));
+//     }
+
+//     const existingOracles = await queryMultipleObjects(
+//       cache,
+//       existingOraclesIds
+//     ).then((res) => {
+//       return res.map((t) => {
+//         const fields: any = getFieldsFromObject(t.content);
+//         return {
+//           oracleId: ObjectParsingHelper.asString(fields.value.fields.oracle_id),
+//           oracleKey: toBase58(
+//             ObjectParsingHelper.asUint8Array(fields.value.fields.oracle_key)
+//           ),
+//         };
+//       });
+//     });
+
+//     const queueData = {
+//       authority: ObjectParsingHelper.asString(queueResponse.authority),
+//       existingOracles,
+//       // get fee number (though encoded as string)
+//       fee: ObjectParsingHelper.asNumber(queueResponse.fee),
+
+//       // fee recipient address
+//       feeRecipient: ObjectParsingHelper.asString(queueResponse.fee_recipient),
+
+//       // accepted fee coin types
+//       feeTypes: ObjectParsingHelper.asArray(queueResponse.fee_types).map(
+//         (ft: any) => ft.fields.name
+//       ),
+
+//       // guardian queue id
+//       guardianQueueId: ObjectParsingHelper.asString(
+//         queueResponse.guardian_queue_id
+//       ),
+
+//       // queue id
+//       id: ObjectParsingHelper.asId(queueResponse.id),
+
+//       // last queue override ms
+//       lastQueueOverrideMs: ObjectParsingHelper.asNumber(
+//         queueResponse.last_queue_override_ms
+//       ),
+
+//       // minimum attestations
+//       minAttestations: ObjectParsingHelper.asNumber(
+//         queueResponse.min_attestations
+//       ),
+
+//       // queue name
+//       name: ObjectParsingHelper.asString(queueResponse.name),
+//       oracleValidityLengthMs: ObjectParsingHelper.asNumber(
+//         queueResponse.oracle_validity_length_ms
+//       ),
+
+//       // get source queue key
+//       queueKey: toBase58(
+//         ObjectParsingHelper.asUint8Array(queueResponse.queue_key) as Uint8Array
+//       ),
+//     } as QueueData;
+
+//     suiQueueCache.set(queueAddress, queueData);
+//   }
+// };
+
+export const updateSwitchboardAggregators = async (
+  builder: ScallopBuilder,
+  assetCoinNames: string[],
+  txBlock: SuiKitTxBlock,
+  solanaRPCUrl: string = 'https://crossbar.switchboard.xyz/rpc/mainnet'
+) => {
+  const switchboardClient = new SwitchboardClient(builder.suiKit.client());
+  const onDemandAggObjects = await queryMultipleObjects(
+    builder.cache,
+    await builder.query.getSwitchboardOnDemandAggregatorObjectIds(
+      assetCoinNames
+    )
+  );
+
+  const feedConfigs = parseFeedConfigs(
+    onDemandAggObjects.map((t) => t.content) as SuiParsedData[]
+  );
+
+  // Get queue addresses
+  // const queueAddresses = feedConfigs.map((fc) => fc.queue);
+
+  // await parseQueueAddresses(builder.cache, queueAddresses);
+
+  for (let idx = 0; idx < assetCoinNames.length; idx++) {
+    // console.log({ coinName: assetCoinNames[idx] });
+    const switchboardAgg = new Aggregator(
+      switchboardClient,
+      onDemandAggObjects[idx].objectId
+    );
+
+    const { responses, failures } = await switchboardAgg.fetchUpdateTx(
+      txBlock.txBlock,
+      {
+        feedConfigs: feedConfigs[idx],
+        solanaRPCUrl,
+      }
+    );
+
+    console.log({ responses, failures });
+    if (failures.length > 0) {
+      throw new Error(
+        `Failed to update aggregator for ${assetCoinNames[idx]}: ${failures.join(',')}`
+      );
+    }
+  }
+  return;
+};

package/src/models/scallopAddress.ts

@@ -443,7 +443,7 @@ export class ScallopAddress {
     instance?: ScallopAddressInstanceParams
   ) {
     const { addressId, auth, network, forceAddressesInterface } = params;
-    this.cache = instance?.cache ?? new ScallopCache({});
+    this.cache = instance?.cache ?? new ScallopCache(params);
 
     this._requestClient = axios.create({
       baseURL: API_BASE_URL,

package/src/models/scallopCache.ts

@@ -246,7 +246,7 @@ export class ScallopCache {
     return query;
   }
 
-  public async queryGetNormalizedMoveFunction(target: string) {
+  private async queryGetNormalizedMoveFunction(target: string) {
     const { address, module, name } = parseStructTag(target);
     return this.queryClient.fetchQuery({
       queryKey: queryKeys.rpc.getNormalizedMoveFunction(target),
@@ -460,11 +460,7 @@ export class ScallopCache {
     input: GetBalanceParams
   ): Promise<CoinBalance | null> {
     if (!input.coinType) return null;
-
-    return (
-      ((await this.queryGetAllCoinBalances(input.owner)) ?? {})[
-        normalizeStructTag(input.coinType)
-      ] ?? '0'
-    );
+    const coinBalances = await this.queryGetAllCoinBalances(input.owner);
+    return coinBalances[normalizeStructTag(input.coinType)] ?? null;
   }
 }

package/src/models/suiKit.ts

@@ -1,11 +1,26 @@
 import { SuiKit, SuiKitParams } from '@scallop-io/sui-kit';
 import { RPC_PROVIDERS } from 'src/constants/rpc';
 
-export const newSuiKit = (params: SuiKitParams) => {
+export const newSuiKit = (params: Partial<SuiKitParams>) => {
+  let initParams;
+  if (
+    'suiClients' in params &&
+    params.suiClients &&
+    params.suiClients?.length > 0
+  ) {
+    initParams = {
+      suiClients: params.suiClients,
+    };
+  } else {
+    initParams = {
+      fullnodeUrls:
+        'fullnodeUrls' in params
+          ? (params?.fullnodeUrls ?? RPC_PROVIDERS)
+          : RPC_PROVIDERS,
+    };
+  }
   return new SuiKit({
     ...params,
-    fullnodeUrls: Array.from(
-      new Set([...(params.fullnodeUrls ?? []), ...RPC_PROVIDERS])
-    ),
+    ...initParams,
   });
 };

package/src/types/model.ts

@@ -74,7 +74,7 @@ export type ScallopCacheParams = {
   walletAddress?: string;
   cacheOptions?: QueryClientConfig;
   config?: ScallopCacheConfig;
-} & SuiKitParams;
+} & Partial<SuiKitParams>;
 
 export type ScallopIndexerParams = ScallopCacheParams & {
   indexerApiUrl?: string;
@@ -99,6 +99,7 @@ export type ScallopConstantsParams = ScallopAddressParams & {
 export type ScallopUtilsParams = ScallopAddressParams &
   ScallopConstantsParams & {
     pythEndpoints?: string[];
+    switchboardSolanaRpc?: string;
   };
 
 export type ScallopQueryParams = ScallopUtilsParams & ScallopIndexerParams;
@@ -109,7 +110,7 @@ export type ScallopBuilderParams = ScallopQueryParams & {
 };
 
 export type ScallopClientParams = ScallopBuilderParams;
-export type ScallopParams = SuiKitParams &
+export type ScallopParams = Partial<SuiKitParams> &
   ScallopAddressParams &
   ScallopConstantsParams & {
     walletAddress?: string;