@pear-protocol/exchanges-sdk 0.6.5 → 0.6.6

package/dist/tracker/hyperliquid/mapper.js

@@ -2,9 +2,12 @@ import BigNumber from 'bignumber.js';
 import { positionKey } from '../utils';
 import { COLLATERAL_TOKEN_MAP, HyperliquidAccountType } from './types';
 
-const LEGACY_COLLATERAL_TOKEN_MAP = new Map(
-  Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [Number(token), coin])
-);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const LEGACY_COLLATERAL_TOKEN_MAP = new Map(Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [
+  Number(token),
+  coin
+]));
 const FULL_UTILIZATION_RATIO = "1.0000";
 const ZERO_COLLATERAL_SUMMARY = {
   accountValue: "0",
@@ -36,26 +39,25 @@ function aggregateClearinghouseStates(states) {
       if (position.position.leverage.type !== "isolated") {
         return [];
       }
-      return [{ collateral: position.position.marginUsed, maintenance: isolatedMaintenanceMargin(dexState, position) }];
+      return [
+        {
+          collateral: position.position.marginUsed,
+          maintenance: isolatedMaintenanceMargin(dexState, position)
+        }
+      ];
     });
     const isolatedMaintenanceMarginUsed = sum(isolatedRisks.map((risk) => risk.maintenance));
     const isolatedMarginUsed = sum(isolatedRisks.map((risk) => risk.collateral));
     let dexMaximumMarginRatio = ratio(state.crossMaintenanceMarginUsed, state.crossMarginSummary.accountValue);
     for (const isolatedRisk of isolatedRisks) {
-      dexMaximumMarginRatio = BigNumber.max(
-        dexMaximumMarginRatio,
-        ratio(isolatedRisk.maintenance, isolatedRisk.collateral)
-      ).toFixed(4);
+      dexMaximumMarginRatio = BigNumber.max(dexMaximumMarginRatio, ratio(isolatedRisk.maintenance, isolatedRisk.collateral)).toFixed(4);
     }
     summary.accountValue = add(summary.accountValue, state.marginSummary.accountValue);
     summary.totalMarginUsed = add(summary.totalMarginUsed, state.marginSummary.totalMarginUsed);
     summary.totalRawUsd = add(summary.totalRawUsd, state.marginSummary.totalRawUsd);
     summary.crossMaintenanceMarginUsed = add(summary.crossMaintenanceMarginUsed, state.crossMaintenanceMarginUsed);
     summary.isolatedMaintenanceMarginUsed = add(summary.isolatedMaintenanceMarginUsed, isolatedMaintenanceMarginUsed);
-    summary.maximumStandardMarginRatio = BigNumber.max(
-      summary.maximumStandardMarginRatio,
-      dexMaximumMarginRatio
-    ).toFixed(4);
+    summary.maximumStandardMarginRatio = BigNumber.max(summary.maximumStandardMarginRatio, dexMaximumMarginRatio).toFixed(4);
     summary.withdrawable = add(summary.withdrawable, state.withdrawable);
     summary.totalUnrealizedPnl = add(summary.totalUnrealizedPnl, unrealizedPnl);
     assetPositions.push(...positions);
@@ -73,8 +75,12 @@ function aggregateClearinghouseStates(states) {
       totalUnrealizedPnl: add(collateral.totalUnrealizedPnl, unrealizedPnl)
     });
   }
-  return { summary, assetPositions };
+  return {
+    summary,
+    assetPositions
+  };
 }
+__name(aggregateClearinghouseStates, "aggregateClearinghouseStates");
 function mapBalance(summary, spotCoinBalances, accountType, collateralTokenMap = LEGACY_COLLATERAL_TOKEN_MAP) {
   if (!accountType) {
     return null;
@@ -88,6 +94,7 @@ function mapBalance(summary, spotCoinBalances, accountType, collateralTokenMap =
       return mapUnifiedBalance(summary, spotCoinBalances, accountType, collateralTokenMap);
   }
 }
+__name(mapBalance, "mapBalance");
 function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const assetPosition of raw) {
@@ -111,6 +118,7 @@ function mapPositions(raw) {
   }
   return positions;
 }
+__name(mapPositions, "mapPositions");
 function mapStandardBalance(summary, accountType, collateralTokenMap) {
   const free = {};
   const used = {};
@@ -150,6 +158,7 @@ function mapStandardBalance(summary, accountType, collateralTokenMap) {
     timestamp: Date.now()
   };
 }
+__name(mapStandardBalance, "mapStandardBalance");
 function mapUnifiedBalance(summary, spotCoinBalances, accountType, collateralTokenMap) {
   const free = {};
   const used = {};
@@ -199,15 +208,19 @@ function mapUnifiedBalance(summary, spotCoinBalances, accountType, collateralTok
     timestamp: Date.now()
   };
 }
+__name(mapUnifiedBalance, "mapUnifiedBalance");
 function unifiedMarginRatio(summary, spotCoinBalances) {
   let maximumRatio = new BigNumber(0);
   for (const [token, collateral] of summary.byCollateralToken) {
-    const spotBalance = [...spotCoinBalances.values()].find((balance) => balance.token === token);
+    const spotBalance = [
+      ...spotCoinBalances.values()
+    ].find((balance) => balance.token === token);
     const available = new BigNumber(spotBalance?.total ?? "0").minus(collateral.isolatedMarginUsed);
     maximumRatio = BigNumber.max(maximumRatio, ratio(collateral.crossMaintenanceMarginUsed, available.toFixed()));
   }
   return maximumRatio.toFixed(4);
 }
+__name(unifiedMarginRatio, "unifiedMarginRatio");
 function isolatedMaintenanceMargin(dexState, assetPosition) {
   const position = assetPosition.position;
   if (position.leverage.type !== "isolated" || position.maxLeverage <= 0) {
@@ -227,36 +240,38 @@ function isolatedMaintenanceMargin(dexState, assetPosition) {
     }
     const previousRate = maintenanceMarginRate(activeTier.maxLeverage);
     const nextRate = maintenanceMarginRate(nextTier.maxLeverage);
-    maintenanceDeduction = maintenanceDeduction.plus(
-      new BigNumber(nextTier.lowerBound).times(nextRate.minus(previousRate))
-    );
+    maintenanceDeduction = maintenanceDeduction.plus(new BigNumber(nextTier.lowerBound).times(nextRate.minus(previousRate)));
     activeTier = nextTier;
   }
   return notional.times(maintenanceMarginRate(activeTier.maxLeverage)).minus(maintenanceDeduction).toFixed();
 }
+__name(isolatedMaintenanceMargin, "isolatedMaintenanceMargin");
 function findMarginTiers(dexState, coin) {
   if (!dexState.meta) {
     return null;
   }
   const unprefixedCoin = dexState.dex && coin.startsWith(`${dexState.dex}:`) ? coin.slice(dexState.dex.length + 1) : coin;
-  const asset = dexState.meta.universe.find(
-    (candidate) => candidate.name === coin || candidate.name === unprefixedCoin
-  );
+  const asset = dexState.meta.universe.find((candidate) => candidate.name === coin || candidate.name === unprefixedCoin);
   const marginTable = dexState.meta.marginTables.find(([id]) => id === asset?.marginTableId)?.[1];
   return marginTable?.marginTiers.length ? marginTable.marginTiers : null;
 }
+__name(findMarginTiers, "findMarginTiers");
 function maintenanceMarginRate(maxLeverage) {
   return new BigNumber(1).div(maxLeverage).div(2);
 }
+__name(maintenanceMarginRate, "maintenanceMarginRate");
 function add(left, right) {
   return new BigNumber(left || "0").plus(right || "0").toFixed();
 }
+__name(add, "add");
 function subtract(left, right) {
   return new BigNumber(left || "0").minus(right || "0").toFixed();
 }
+__name(subtract, "subtract");
 function sum(values) {
   return values.reduce((total, value) => total.plus(value || "0"), new BigNumber(0)).toFixed();
 }
+__name(sum, "sum");
 function ratio(numerator, denominator) {
   const numeratorValue = new BigNumber(numerator || "0");
   const denominatorValue = new BigNumber(denominator || "0");
@@ -265,5 +280,6 @@ function ratio(numerator, denominator) {
   }
   return numeratorValue.gt(0) ? FULL_UTILIZATION_RATIO : "0.0000";
 }
+__name(ratio, "ratio");
 
 export { aggregateClearinghouseStates, mapBalance, mapPositions };

package/dist/tracker/hyperliquid/tracker.js

@@ -6,7 +6,12 @@ import { LOCKED_TRACKED_COINS } from './const';
 import { aggregateClearinghouseStates, mapBalance, mapPositions } from './mapper';
 import { HyperliquidAccountType, COLLATERAL_TOKEN_MAP } from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 class HyperliquidAccountTracker extends BaseAccountTracker {
+  static {
+    __name(this, "HyperliquidAccountTracker");
+  }
   address;
   ws = null;
   messageListenerId = null;
@@ -26,42 +31,45 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.address = config.account.exchangeIdentifier;
   }
   /**
-   * Reads account mode, collateral balances, per-DEX state, and positions without opening a socket.
-   */
+  * Reads account mode, collateral balances, per-DEX state, and positions without opening a socket.
+  */
   async snapshot() {
     const user = this.addrLower();
     const [perpDexs, allMetas, spotMeta, abstraction, spotState] = await Promise.all([
       fetchPerpDexs(this.demo),
-      fetchInfo({ type: "allPerpMetas" }, this.demo),
-      fetchInfo({ type: "spotMeta" }, this.demo),
+      fetchInfo({
+        type: "allPerpMetas"
+      }, this.demo),
+      fetchInfo({
+        type: "spotMeta"
+      }, this.demo),
       fetchUserAbstraction(user, this.demo),
       fetchSpotClearinghouseState(user, this.demo)
     ]);
     const descriptors = uniqueDexDescriptors(perpDexs, allMetas);
-    const clearinghouseStates = await Promise.all(
-      descriptors.map(
-        async ({ dex, meta }) => ({
-          dex,
-          collateralToken: meta?.collateralToken ?? null,
-          meta,
-          state: await fetchClearinghouseState(user, dex, this.demo)
-        })
-      )
-    );
+    const clearinghouseStates = await Promise.all(descriptors.map(async ({ dex, meta }) => ({
+      dex,
+      collateralToken: meta?.collateralToken ?? null,
+      meta,
+      state: await fetchClearinghouseState(user, dex, this.demo)
+    })));
     const { summary, assetPositions } = aggregateClearinghouseStates(clearinghouseStates);
     const accountType = resolveHyperliquidAccountType(abstraction);
     const collateralTokenMap = buildCollateralTokenMap(allMetas, spotMeta);
     const spotCoinBalances = mapSpotBalances(spotState);
     const balance = mapBalance(summary, spotCoinBalances, accountType, collateralTokenMap);
     const positions = Array.from(mapPositions(assetPositions).values());
-    return { balance, positions };
+    return {
+      balance,
+      positions
+    };
   }
   /**
-   * Stateless one-shot per-asset settings read via the `activeAssetData` info request (the REST
-   * twin of the live WS subscription), one request per coin fired in parallel — the info endpoint
-   * has no batch form. Per-coin reads are tolerant (a failed coin maps to `null`); the read only
-   * throws if every coin fetch fails.
-   */
+  * Stateless one-shot per-asset settings read via the `activeAssetData` info request (the REST
+  * twin of the live WS subscription), one request per coin fired in parallel — the info endpoint
+  * has no batch form. Per-coin reads are tolerant (a failed coin maps to `null`); the read only
+  * throws if every coin fetch fails.
+  */
   async fetchAssetSnapshots(coins) {
     const user = this.addrLower();
     const settled = await Promise.allSettled(coins.map((coin) => fetchActiveAssetData(user, coin, this.demo)));
@@ -83,16 +91,23 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.resetLiveAccountState();
     this.dexToMeta.clear();
     const [allMetas, perpDexs, spotMeta, abstraction] = await Promise.all([
-      fetchInfo({ type: "allPerpMetas" }, this.demo),
+      fetchInfo({
+        type: "allPerpMetas"
+      }, this.demo),
       fetchPerpDexs(this.demo),
-      fetchInfo({ type: "spotMeta" }, this.demo),
+      fetchInfo({
+        type: "spotMeta"
+      }, this.demo),
       fetchUserAbstraction(user, this.demo)
     ]);
     if (lifecycleVersion !== this.lifecycleVersion) return;
     this.loadPerpMetas(allMetas, perpDexs);
     this.collateralTokenMap = buildCollateralTokenMap(allMetas, spotMeta);
     this.accountType = resolveHyperliquidAccountType(abstraction);
-    const ws = (await createExchangeWs("hyperliquid", { demo: this.demo, credentials: this.credentials })).main;
+    const ws = (await createExchangeWs("hyperliquid", {
+      demo: this.demo,
+      credentials: this.credentials
+    })).main;
     if (lifecycleVersion !== this.lifecycleVersion) {
       ws.destroy();
       return;
@@ -101,7 +116,10 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.messageListenerId = this.ws.addMessageListener((raw) => this.routeRaw(raw));
     this.openListenerId = this.ws.addOpenListener(() => this.resubscribeAll());
     this.sendStaticSubs();
-    const coinsToTrack = /* @__PURE__ */ new Set([...LOCKED_TRACKED_COINS, ...this.trackedCoins]);
+    const coinsToTrack = /* @__PURE__ */ new Set([
+      ...LOCKED_TRACKED_COINS,
+      ...this.trackedCoins
+    ]);
     for (const coin of coinsToTrack) {
       this.ensureAssetTracked(coin);
     }
@@ -132,7 +150,11 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.subscribedCoins.add(coin);
     this.ws?.send({
       method: "subscribe",
-      subscription: { type: "activeAssetData", coin, user: this.addrLower() }
+      subscription: {
+        type: "activeAssetData",
+        coin,
+        user: this.addrLower()
+      }
     });
   }
   releaseAsset(coin) {
@@ -141,10 +163,16 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.subscribedCoins.delete(coin);
     this.ws?.send({
       method: "unsubscribe",
-      subscription: { type: "activeAssetData", coin, user: this.addrLower() }
+      subscription: {
+        type: "activeAssetData",
+        coin,
+        user: this.addrLower()
+      }
     });
     this.trackedAssetData.delete(coin);
-    this.onStateUpdate({ trackedAssets: this.buildTrackedAssetsMap() });
+    this.onStateUpdate({
+      trackedAssets: this.buildTrackedAssetsMap()
+    });
   }
   isLocked(coin) {
     return LOCKED_TRACKED_COINS.includes(coin);
@@ -154,15 +182,37 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   }
   sendStaticSubs() {
     const user = this.addrLower();
-    this.ws?.send({ method: "subscribe", subscription: { type: "allDexsClearinghouseState", user } });
+    this.ws?.send({
+      method: "subscribe",
+      subscription: {
+        type: "allDexsClearinghouseState",
+        user
+      }
+    });
     this.sendSpotStateSubscription("subscribe", this.accountType);
-    this.ws?.send({ method: "subscribe", subscription: { type: "webData3", user } });
+    this.ws?.send({
+      method: "subscribe",
+      subscription: {
+        type: "webData3",
+        user
+      }
+    });
   }
   /** Subscribes to the spot state variant required by the active account mode. */
   sendSpotStateSubscription(method, accountType) {
     const user = this.addrLower();
-    const subscription = accountType === HyperliquidAccountType.PORTFOLIO_MARGIN ? { type: "spotState", user, isPortfolioMargin: true } : { type: "spotState", user };
-    this.ws?.send({ method, subscription });
+    const subscription = accountType === HyperliquidAccountType.PORTFOLIO_MARGIN ? {
+      type: "spotState",
+      user,
+      isPortfolioMargin: true
+    } : {
+      type: "spotState",
+      user
+    };
+    this.ws?.send({
+      method,
+      subscription
+    });
   }
   resubscribeAll() {
     this.resetLiveAccountState();
@@ -171,7 +221,11 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     for (const coin of this.subscribedCoins) {
       this.ws?.send({
         method: "subscribe",
-        subscription: { type: "activeAssetData", coin, user }
+        subscription: {
+          type: "activeAssetData",
+          coin,
+          user
+        }
       });
     }
   }
@@ -181,16 +235,28 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       if (!msg.channel || !msg.data) return;
       switch (msg.channel) {
         case "allDexsClearinghouseState":
-          this.handle({ kind: "clearinghouseState", data: msg.data });
+          this.handle({
+            kind: "clearinghouseState",
+            data: msg.data
+          });
           break;
         case "spotState":
-          this.handle({ kind: "spotState", data: msg.data });
+          this.handle({
+            kind: "spotState",
+            data: msg.data
+          });
           break;
         case "webData3":
-          this.handle({ kind: "webData3", data: msg.data });
+          this.handle({
+            kind: "webData3",
+            data: msg.data
+          });
           break;
         case "activeAssetData":
-          this.handle({ kind: "activeAssetData", data: msg.data });
+          this.handle({
+            kind: "activeAssetData",
+            data: msg.data
+          });
           break;
       }
     } catch (err) {
@@ -220,23 +286,23 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     });
   }
   onClearinghouseState(data) {
-    const states = (data.clearinghouseStates || []).flatMap(
-      ([dex, state]) => state ? [
-        {
-          dex,
-          collateralToken: this.dexToMeta.get(dex)?.collateralToken ?? null,
-          meta: this.dexToMeta.get(dex) ?? null,
-          state
-        }
-      ] : []
-    );
+    const states = (data.clearinghouseStates || []).flatMap(([dex, state]) => state ? [
+      {
+        dex,
+        collateralToken: this.dexToMeta.get(dex)?.collateralToken ?? null,
+        meta: this.dexToMeta.get(dex) ?? null,
+        state
+      }
+    ] : []);
     const { summary, assetPositions } = aggregateClearinghouseStates(states);
     this.lastSummary = summary;
     this.hasClearinghouseState = true;
     const balance = this.buildBalance();
     const positions = mapPositions(assetPositions);
     this.onStateUpdate({
-      ...balance === void 0 ? {} : { balance },
+      ...balance === void 0 ? {} : {
+        balance
+      },
       positions,
       positionsMode: "replace"
     });
@@ -247,7 +313,9 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.trackedAssetData.set(data.coin, data);
     const trackedAssets = /* @__PURE__ */ new Map();
     trackedAssets.set(data.coin, buildTrackedAssetInfo(data));
-    this.onStateUpdate({ trackedAssets });
+    this.onStateUpdate({
+      trackedAssets
+    });
   }
   onWebData3(data) {
     const previousAccountType = this.accountType;
@@ -262,12 +330,16 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     }
     this.accountType = nextAccountType;
     if (!nextAccountType) {
-      this.onStateUpdate({ balance: null });
+      this.onStateUpdate({
+        balance: null
+      });
       return;
     }
     const balance = this.buildBalance();
     if (balance !== void 0) {
-      this.onStateUpdate({ balance });
+      this.onStateUpdate({
+        balance
+      });
     }
   }
   onSpotState(data) {
@@ -277,7 +349,9 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.hasSpotState = true;
     const balance = this.buildBalance();
     if (balance !== void 0) {
-      this.onStateUpdate({ balance });
+      this.onStateUpdate({
+        balance
+      });
     }
   }
   buildBalance() {
@@ -312,6 +386,7 @@ function buildTrackedAssetInfo(data) {
     marginType: data.leverage?.type
   };
 }
+__name(buildTrackedAssetInfo, "buildTrackedAssetInfo");
 const HYPERLIQUID_ACCOUNT_TYPES = Object.values(HyperliquidAccountType);
 function toHyperliquidAccountType(abstraction) {
   if (!abstraction) {
@@ -319,9 +394,11 @@ function toHyperliquidAccountType(abstraction) {
   }
   return HYPERLIQUID_ACCOUNT_TYPES.includes(abstraction) ? abstraction : null;
 }
+__name(toHyperliquidAccountType, "toHyperliquidAccountType");
 function resolveHyperliquidAccountType(abstraction) {
   return toHyperliquidAccountType(abstraction);
 }
+__name(resolveHyperliquidAccountType, "resolveHyperliquidAccountType");
 function uniqueDexDescriptors(perpDexs, allMetas) {
   const seen = /* @__PURE__ */ new Set();
   return perpDexs.flatMap((descriptor, index) => {
@@ -330,9 +407,15 @@ function uniqueDexDescriptors(perpDexs, allMetas) {
       return [];
     }
     seen.add(dex);
-    return [{ dex, meta: allMetas[index] ?? null }];
+    return [
+      {
+        dex,
+        meta: allMetas[index] ?? null
+      }
+    ];
   });
 }
+__name(uniqueDexDescriptors, "uniqueDexDescriptors");
 function mapSpotBalances(spotState) {
   const balances = /* @__PURE__ */ new Map();
   const availableAfterMaintenance = new Map(spotState.tokenToAvailableAfterMaintenance ?? []);
@@ -350,6 +433,7 @@ function mapSpotBalances(spotState) {
   }
   return balances;
 }
+__name(mapSpotBalances, "mapSpotBalances");
 function emptySummary() {
   return {
     accountValue: "0",
@@ -363,8 +447,12 @@ function emptySummary() {
     byCollateralToken: /* @__PURE__ */ new Map()
   };
 }
+__name(emptySummary, "emptySummary");
 function buildCollateralTokenMap(allMetas, spotMeta) {
-  const spotTokenNames = new Map(spotMeta.tokens.map((token) => [token.index, token.name]));
+  const spotTokenNames = new Map(spotMeta.tokens.map((token) => [
+    token.index,
+    token.name
+  ]));
   const result = /* @__PURE__ */ new Map();
   for (const meta of allMetas) {
     const token = meta.collateralToken;
@@ -375,8 +463,13 @@ function buildCollateralTokenMap(allMetas, spotMeta) {
   }
   return result;
 }
+__name(buildCollateralTokenMap, "buildCollateralTokenMap");
 function legacyCollateralTokenMap() {
-  return new Map(Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [Number(token), coin]));
+  return new Map(Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [
+    Number(token),
+    coin
+  ]));
 }
+__name(legacyCollateralTokenMap, "legacyCollateralTokenMap");
 
 export { HyperliquidAccountTracker };

package/dist/tracker/hyperliquid/types.js

@@ -1,10 +1,10 @@
-var HyperliquidAccountType = /* @__PURE__ */ ((HyperliquidAccountType2) => {
+var HyperliquidAccountType = /* @__PURE__ */ (function(HyperliquidAccountType2) {
   HyperliquidAccountType2["DEFAULT"] = "default";
   HyperliquidAccountType2["DISABLED"] = "disabled";
   HyperliquidAccountType2["PORTFOLIO_MARGIN"] = "portfolioMargin";
   HyperliquidAccountType2["UNIFIED_ACCOUNT"] = "unifiedAccount";
   return HyperliquidAccountType2;
-})(HyperliquidAccountType || {});
+})({});
 const COLLATERAL_TOKEN_MAP = {
   0: "USDC",
   235: "USDE",

package/dist/tracker/index.js

@@ -16,6 +16,8 @@ export { LighterAccountType } from './lighter/types';
 export { OkxAccountType } from './okx/types';
 export * from './types';
 
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function createAccountTracker(exchange, config) {
   switch (exchange) {
     case "binance":
@@ -57,5 +59,6 @@ function createAccountTracker(exchange, config) {
     }
   }
 }
+__name(createAccountTracker, "createAccountTracker");
 
 export { createAccountTracker };