@townsq/mm-sdk 1.0.1

package/src/lifeline/modules/ts-oracle.ts

@@ -0,0 +1,68 @@
+import { TSHubOracle } from '../../chains/evm/hub/modules/index.js';
+import {
+  getHubTokenData,
+  getHubTokensData,
+} from '../../chains/evm/hub/utils/chain.js';
+import { TSCore } from '../core/ts-core.js';
+
+import type {
+  OraclePrice,
+  OraclePrices,
+  OracleNodePrice,
+  OracleNodePrices,
+  OracleNode,
+} from '../../chains/evm/hub/types/oracle.js';
+import type { TSTokenId } from '../../common/types/token.js';
+
+export const read = {
+  async oraclePrice(
+    tsTokenId: TSTokenId,
+    blockNumber?: bigint
+  ): Promise<OraclePrice> {
+    const network = TSCore.getSelectedNetwork();
+    const { poolId } = getHubTokenData(tsTokenId, network);
+    return await TSHubOracle.getOraclePrice(
+      TSCore.getHubProvider(),
+      network,
+      poolId,
+      blockNumber
+    );
+  },
+
+  async oraclePrices(
+    tsTokenIds?: Array<TSTokenId>,
+    blockNumber?: bigint
+  ): Promise<OraclePrices> {
+    const network = TSCore.getSelectedNetwork();
+    const tokensData = tsTokenIds
+      ? tsTokenIds.map((tsTokenId) => getHubTokenData(tsTokenId, network))
+      : Object.values(getHubTokensData(network));
+    return TSHubOracle.getOraclePrices(
+      TSCore.getHubProvider(),
+      network,
+      tokensData,
+      blockNumber
+    );
+  },
+
+  async oracleNodePrice(oracleNode: OracleNode): Promise<OracleNodePrice> {
+    const network = TSCore.getSelectedNetwork();
+    return await TSHubOracle.getNodePrice(
+      TSCore.getHubProvider(),
+      network,
+      oracleNode
+    );
+  },
+
+  async oracleNodePrices(
+    oracleNodes: Array<OracleNode>
+  ): Promise<OracleNodePrices> {
+    const network = TSCore.getSelectedNetwork();
+    const nodes = oracleNodes;
+    return await TSHubOracle.getNodePrices(
+      TSCore.getHubProvider(),
+      network,
+      nodes
+    );
+  },
+};

package/src/lifeline/modules/ts-pool.ts

@@ -0,0 +1,19 @@
+import { TSHubPool } from '../../chains/evm/hub/modules/index.js';
+import { TSCore } from '../core/ts-core.js';
+
+import type { PoolInfo } from '../../chains/evm/hub/types/pool.js';
+import type { TSTokenId } from '../../common/types/token.js';
+
+export const read = {
+  async poolInfo(
+    tsTokenId: TSTokenId,
+    blockNumber?: bigint
+  ): Promise<PoolInfo> {
+    return TSHubPool.getPoolInfo(
+      TSCore.getHubProvider(),
+      TSCore.getSelectedNetwork(),
+      tsTokenId,
+      blockNumber
+    );
+  },
+};

package/src/types/generics.ts

@@ -0,0 +1 @@
+export type NonEmptyArray<T> = [T, ...Array<T>];

package/src/utils/array.ts

@@ -0,0 +1,11 @@
+import type { NonEmptyArray } from "../types/generics.js";
+
+export const intersect =
+  <T>(arr: Array<T>) =>
+  (x: T) =>
+    arr.includes(x);
+
+export const ensureNonEmpty = <T>(arr: Array<T>, errMsg?: string): NonEmptyArray<T> => {
+  if (arr.length === 0) throw new Error(errMsg ?? "Array cannot be empty");
+  return arr as NonEmptyArray<T>;
+};

package/src/utils/exhaustive-check.ts

@@ -0,0 +1,3 @@
+export const exhaustiveCheck = (value: never): never => {
+  throw new Error(`ERROR, Reached forbidden guard function with unexpected value: ${JSON.stringify(value)}`);
+};

package/src/utils/random.ts

@@ -0,0 +1,3 @@
+export function getRandomElement<T>(arr: ReadonlyArray<T>): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}