@across-protocol/sdk 4.3.50 → 4.3.52

package/src/clients/BundleDataClient/utils/DataworkerUtils.ts

@@ -10,6 +10,7 @@ import {
   PoolRebalanceLeaf,
   Refund,
   RunningBalances,
+  SpokePoolClientsByChain,
 } from "../../../interfaces";
 import {
   bnZero,
@@ -18,6 +19,9 @@ import {
   count2DDictionaryValues,
   count3DDictionaryValues,
   toAddressType,
+  getImpliedBundleBlockRanges,
+  isDefined,
+  EvmAddress,
 } from "../../../utils";
 import {
   addLastRunningBalance,
@@ -28,6 +32,7 @@ import {
 } from "./PoolRebalanceUtils";
 import { AcrossConfigStoreClient } from "../../AcrossConfigStoreClient";
 import { HubPoolClient } from "../../HubPoolClient";
+import { BundleDataClient } from "../../BundleDataClient";
 import { buildPoolRebalanceLeafTree } from "./MerkleTreeUtils";
 
 // and expired deposits.
@@ -114,7 +119,22 @@ export function getEndBlockBuffers(
   return chainIdListForBundleEvaluationBlockNumbers.map((chainId: number) => blockRangeEndBlockBuffer[chainId] ?? 0);
 }
 
-export function _buildPoolRebalanceRoot(
+/*
+ * @notice Constructs a new pool rebalance root given the input bundle data.
+ * @dev It is assumed that the input bundle data corresponds to the block ranges of the input mainnetBundleEndBlock.
+ * If the mainnetBundleEndBlock does not correspond to any historical or pending root bundle, then the output pool rebalance
+ * root will be constructed under the assumption that the pending root bundle is valid and passes liveness.
+ * @param latestMainnetBlock The latest mainnet block number.
+ * @param mainnetBundleEndBlock The end block number of the block range corresponding to the bundle data.
+ * @param bundleV3Deposits Deposit bundle data for the implied block range given by the mainnetBundleEndBlock.
+ * @param bundleFillsV3 Fill bundle data.
+ * @param bundleSlowFillsV3 Slow fill bundle data.
+ * @param unexecutableSlowFills Expired slow fill bundle data.
+ * @param expiredDepositsToRefundV3 Expired deposit bundle data.
+ * @param clients Clients required to construct a new pool rebalance root.
+ * @maxL1TokenCountOverride Optional parameter to cap the number of tokens in a single pool rebalance leaf.
+ */
+export async function _buildPoolRebalanceRoot(
   latestMainnetBlock: number,
   mainnetBundleEndBlock: number,
   bundleV3Deposits: BundleDepositsV3,
@@ -122,9 +142,235 @@ export function _buildPoolRebalanceRoot(
   bundleSlowFillsV3: BundleSlowFills,
   unexecutableSlowFills: BundleExcessSlowFills,
   expiredDepositsToRefundV3: ExpiredDepositsToRefundV3,
-  clients: { hubPoolClient: HubPoolClient; configStoreClient: AcrossConfigStoreClient },
+  clients: {
+    hubPoolClient: HubPoolClient;
+    configStoreClient: AcrossConfigStoreClient;
+    bundleDataClient: BundleDataClient;
+    spokePoolClients: SpokePoolClientsByChain;
+  },
+  maxL1TokenCountOverride?: number
+): Promise<PoolRebalanceRoot> {
+  // If there is a pending proposal and the mainnet bundle end block is greater than the pending proposal's mainnet end block, then this pool rebalance root is being built during the liveness
+  // of a different root bundle, so running balance calculations will be slightly different.
+  if (
+    clients.hubPoolClient.hasPendingProposal() &&
+    clients.hubPoolClient.getPendingRootBundle()!.bundleEvaluationBlockNumbers[0] < mainnetBundleEndBlock
+  ) {
+    return await _buildOptimisticPoolRebalanceRoot(
+      latestMainnetBlock,
+      mainnetBundleEndBlock,
+      bundleV3Deposits,
+      bundleFillsV3,
+      bundleSlowFillsV3,
+      unexecutableSlowFills,
+      expiredDepositsToRefundV3,
+      clients,
+      maxL1TokenCountOverride
+    );
+  }
+  // Otherwise, we can synchronously reconstruct a historical pool rebalance root from the input data.
+  return _buildHistoricalPoolRebalanceRoot(
+    latestMainnetBlock,
+    mainnetBundleEndBlock,
+    bundleV3Deposits,
+    bundleFillsV3,
+    bundleSlowFillsV3,
+    unexecutableSlowFills,
+    expiredDepositsToRefundV3,
+    clients,
+    maxL1TokenCountOverride
+  );
+}
+
+/*
+ * @notice Constructs a new pool rebalance root given historical bundle data.
+ * @param latestMainnetBlock The latest mainnet block number.
+ * @param mainnetBundleEndBlock The end block number of the block range corresponding to the bundle data.
+ * @param bundleV3Deposits Deposit bundle data for the implied block range given by the mainnetBundleEndBlock.
+ * @param bundleFillsV3 Fill bundle data.
+ * @param bundleSlowFillsV3 Slow fill bundle data.
+ * @param unexecutableSlowFills Expired slow fill bundle data.
+ * @param expiredDepositsToRefundV3 Expired deposit bundle data.
+ * @param clients Clients required to construct a new pool rebalance root.
+ * @maxL1TokenCountOverride Optional parameter to cap the number of tokens in a single pool rebalance leaf.
+ */
+export function _buildHistoricalPoolRebalanceRoot(
+  latestMainnetBlock: number,
+  mainnetBundleEndBlock: number,
+  bundleV3Deposits: BundleDepositsV3,
+  bundleFillsV3: BundleFillsV3,
+  bundleSlowFillsV3: BundleSlowFills,
+  unexecutableSlowFills: BundleExcessSlowFills,
+  expiredDepositsToRefundV3: ExpiredDepositsToRefundV3,
+  clients: {
+    hubPoolClient: HubPoolClient;
+    configStoreClient: AcrossConfigStoreClient;
+  },
   maxL1TokenCountOverride?: number
 ): PoolRebalanceRoot {
+  const { runningBalances, realizedLpFees, chainWithRefundsOnly } = _getMarginalRunningBalances(
+    mainnetBundleEndBlock,
+    bundleV3Deposits,
+    bundleFillsV3,
+    bundleSlowFillsV3,
+    unexecutableSlowFills,
+    expiredDepositsToRefundV3,
+    clients
+  );
+  addLastRunningBalance(latestMainnetBlock, runningBalances, clients.hubPoolClient);
+  const leaves: PoolRebalanceLeaf[] = constructPoolRebalanceLeaves(
+    mainnetBundleEndBlock,
+    runningBalances,
+    realizedLpFees,
+    Array.from(chainWithRefundsOnly).filter((chainId) => !Object.keys(runningBalances).includes(chainId.toString())),
+    clients.configStoreClient,
+    maxL1TokenCountOverride
+  );
+  return {
+    runningBalances,
+    realizedLpFees,
+    leaves,
+    tree: buildPoolRebalanceLeafTree(leaves),
+  };
+}
+
+/*
+ * @notice Constructs a new pool rebalance root given the input bundle data. This function assumes there is a pending root bundle which will eventually clear liveness.
+ * @param latestMainnetBlock The latest mainnet block number.
+ * @param mainnetBundleEndBlock The end block number of the block range corresponding to the bundle data.
+ * @param bundleV3Deposits Deposit bundle data for the implied block range given by the mainnetBundleEndBlock.
+ * @param bundleFillsV3 Fill bundle data.
+ * @param bundleSlowFillsV3 Slow fill bundle data.
+ * @param unexecutableSlowFills Expired slow fill bundle data.
+ * @param expiredDepositsToRefundV3 Expired deposit bundle data.
+ * @param clients Clients required to construct a new pool rebalance root.
+ * @maxL1TokenCountOverride Optional parameter to cap the number of tokens in a single pool rebalance leaf.
+ */
+export async function _buildOptimisticPoolRebalanceRoot(
+  latestMainnetBlock: number,
+  mainnetBundleEndBlock: number,
+  bundleV3Deposits: BundleDepositsV3,
+  bundleFillsV3: BundleFillsV3,
+  bundleSlowFillsV3: BundleSlowFills,
+  unexecutableSlowFills: BundleExcessSlowFills,
+  expiredDepositsToRefundV3: ExpiredDepositsToRefundV3,
+  clients: {
+    hubPoolClient: HubPoolClient;
+    configStoreClient: AcrossConfigStoreClient;
+    bundleDataClient: BundleDataClient;
+    spokePoolClients: SpokePoolClientsByChain;
+  },
+  maxL1TokenCountOverride?: number
+): Promise<PoolRebalanceRoot> {
+  const { runningBalances, realizedLpFees, chainWithRefundsOnly } = _getMarginalRunningBalances(
+    mainnetBundleEndBlock,
+    bundleV3Deposits,
+    bundleFillsV3,
+    bundleSlowFillsV3,
+    unexecutableSlowFills,
+    expiredDepositsToRefundV3,
+    clients
+  );
+  // Get the pool rebalance root for the pending bundle so that we may account for its calculated running balances.
+  // @dev It is safe to index the hub pool client's proposed root bundles here since there is guaranteed to be a pending proposal in this code block.
+  const mostRecentProposedRootBundle = clients.hubPoolClient.getLatestProposedRootBundle();
+  const blockRangesForChains = getImpliedBundleBlockRanges(
+    clients.hubPoolClient,
+    clients.configStoreClient,
+    mostRecentProposedRootBundle
+  );
+  // We are loading data from a pending root bundle which should be well into liveness, so we want to use arweave if possible.
+  const pendingRootBundleData = await clients.bundleDataClient.loadData(
+    blockRangesForChains,
+    clients.spokePoolClients,
+    true
+  );
+  // Build the pool rebalance root for the pending root bundle.
+  const { leaves, tree } = _buildHistoricalPoolRebalanceRoot(
+    latestMainnetBlock,
+    blockRangesForChains[0][1],
+    pendingRootBundleData.bundleDepositsV3,
+    pendingRootBundleData.bundleFillsV3,
+    pendingRootBundleData.bundleSlowFillsV3,
+    pendingRootBundleData.unexecutableSlowFills,
+    pendingRootBundleData.expiredDepositsToRefundV3,
+    clients,
+    maxL1TokenCountOverride
+  );
+  // Assert that the rebuilt pool rebalance root matches the pending root bundle's value. If it does not, then we likely misconstructed the pending root bundle and should throw.
+  assert(tree.getHexRoot() === mostRecentProposedRootBundle.poolRebalanceRoot);
+
+  // Only add marginal pending running balances if there is already an entry in `runningBalances`. If there is no entry in `runningBalances`, then
+  // The running balance for this entry was unchanged since the last root bundle.
+  Object.keys(runningBalances).forEach((_repaymentChainId) => {
+    Object.keys(runningBalances[Number(_repaymentChainId)]).forEach((_l1TokenAddress) => {
+      const repaymentChainId = Number(_repaymentChainId);
+      const l1TokenAddress = EvmAddress.from(_l1TokenAddress);
+      const pendingPoolRebalanceLeaf = leaves.find(
+        (leaf) => leaf.chainId === repaymentChainId && leaf.l1Tokens.some((l1Token) => l1Token.eq(l1TokenAddress))
+      );
+      // If the pending pool rebalance root has running balances defined, then add it to `runningBalances`.
+      if (isDefined(pendingPoolRebalanceLeaf)) {
+        const pendingLeafTokenIdx = pendingPoolRebalanceLeaf.l1Tokens.findIndex((l1Token) =>
+          l1Token.eq(l1TokenAddress)
+        );
+        assert(pendingLeafTokenIdx !== -1);
+        const pendingRunningBalanceAmount = pendingPoolRebalanceLeaf.runningBalances[pendingLeafTokenIdx];
+        if (!pendingRunningBalanceAmount.eq(bnZero)) {
+          updateRunningBalance(runningBalances, repaymentChainId, _l1TokenAddress, pendingRunningBalanceAmount);
+        }
+      } else {
+        // Otherwise, add the last running balance for this token.
+        const { runningBalance: lastExecutedBundleRunningBalance } =
+          clients.hubPoolClient.getRunningBalanceBeforeBlockForChain(
+            latestMainnetBlock,
+            repaymentChainId,
+            l1TokenAddress
+          );
+        if (!lastExecutedBundleRunningBalance.eq(bnZero)) {
+          updateRunningBalance(runningBalances, repaymentChainId, _l1TokenAddress, lastExecutedBundleRunningBalance);
+        }
+      }
+    });
+  });
+  const poolRebalanceLeaves: PoolRebalanceLeaf[] = constructPoolRebalanceLeaves(
+    mainnetBundleEndBlock,
+    runningBalances,
+    realizedLpFees,
+    Array.from(chainWithRefundsOnly).filter((chainId) => !Object.keys(runningBalances).includes(chainId.toString())),
+    clients.configStoreClient,
+    maxL1TokenCountOverride
+  );
+  return {
+    runningBalances,
+    realizedLpFees,
+    leaves: poolRebalanceLeaves,
+    tree: buildPoolRebalanceLeafTree(poolRebalanceLeaves),
+  };
+}
+
+/*
+ * @notice Gets the running balance amounts derived from the input bundle data.
+ * @param mainnetBundleEndBlock The end block number of the block range corresponding to the bundle data.
+ * @param bundleV3Deposits Deposit bundle data for the implied block range given by the mainnetBundleEndBlock.
+ * @param bundleFillsV3 Fill bundle data.
+ * @param bundleSlowFillsV3 Slow fill bundle data.
+ * @param unexecutableSlowFills Expired slow fill bundle data.
+ * @param expiredDepositsToRefundV3 Expired deposit bundle data.
+ * @param clients Clients required to construct a new pool rebalance root.
+ */
+export function _getMarginalRunningBalances(
+  mainnetBundleEndBlock: number,
+  bundleV3Deposits: BundleDepositsV3,
+  bundleFillsV3: BundleFillsV3,
+  bundleSlowFillsV3: BundleSlowFills,
+  unexecutableSlowFills: BundleExcessSlowFills,
+  expiredDepositsToRefundV3: ExpiredDepositsToRefundV3,
+  clients: {
+    hubPoolClient: HubPoolClient;
+    configStoreClient: AcrossConfigStoreClient;
+  }
+): { chainWithRefundsOnly: Set<number>; realizedLpFees: RunningBalances; runningBalances: RunningBalances } {
   // Running balances are the amount of tokens that we need to send to each SpokePool to pay for all instant and
   // slow relay refunds. They are decreased by the amount of funds already held by the SpokePool. Balances are keyed
   // by the SpokePool's network and L1 token equivalent of the L2 token to refund.
@@ -296,24 +542,5 @@ export function _buildPoolRebalanceRoot(
       });
     });
   });
-
-  // Add to the running balance value from the last valid root bundle proposal for {chainId, l1Token}
-  // combination if found.
-  addLastRunningBalance(latestMainnetBlock, runningBalances, clients.hubPoolClient);
-
-  const leaves: PoolRebalanceLeaf[] = constructPoolRebalanceLeaves(
-    mainnetBundleEndBlock,
-    runningBalances,
-    realizedLpFees,
-    Array.from(chainWithRefundsOnly).filter((chainId) => !Object.keys(runningBalances).includes(chainId.toString())),
-    clients.configStoreClient,
-    maxL1TokenCountOverride
-  );
-
-  return {
-    runningBalances,
-    realizedLpFees,
-    leaves,
-    tree: buildPoolRebalanceLeafTree(leaves),
-  };
+  return { runningBalances, chainWithRefundsOnly, realizedLpFees };
 }

package/src/coingecko/Coingecko.ts

@@ -29,6 +29,12 @@ type PriceCache = {
   };
 };
 
+type PriceCacheBySymbol = {
+  [symbol: string]: {
+    [currency: string]: Omit<CoinGeckoPrice, "address">;
+  };
+};
+
 type CGTokenPrice = {
   [currency: string]: number;
   last_updated_at: number;
@@ -61,6 +67,7 @@ export type HistoricPriceChartData = {
 export class Coingecko {
   private static instance: Coingecko | undefined;
   private prices: PriceCache;
+  private pricesBySymbol: PriceCacheBySymbol;
   private _maxPriceAge = 300; // seconds
 
   // Retry configuration.
@@ -103,6 +110,7 @@ export class Coingecko {
     private readonly customPlatformIdMap?: Record<number, string>
   ) {
     this.prices = {};
+    this.pricesBySymbol = {};
   }
 
   protected async getPlatformId(chainId: number): Promise<string> {
@@ -281,6 +289,29 @@ export class Coingecko {
     return [tokenPrice.timestamp.toString(), tokenPrice.price];
   }
 
+  async getCurrentPriceBySymbol(symbol: string, currency = "usd"): Promise<[string, number]> {
+    let tokenPrice = this.getCachedSymbolPrice(symbol, currency);
+    if (tokenPrice === undefined) {
+      const result = await this.call<Record<string, CGTokenPrice>>(
+        `simple/price?symbols=${symbol}&vs_currencies=${currency}&include_last_updated_at=true`
+      );
+      const cgPrice = result?.[symbol.toLowerCase()];
+      if (cgPrice === undefined || !cgPrice?.[currency]) {
+        const errMsg = `Failed to retrieve ${symbol}/${currency} price via Coingecko API`;
+        this.logger.debug({
+          at: "Coingecko#getCurrentPriceBySymbol",
+          message: errMsg,
+        });
+        throw new Error(errMsg);
+      } else {
+        this.updatePriceCacheBySymbol(cgPrice, symbol, currency);
+      }
+    }
+    tokenPrice = this.getCachedSymbolPrice(symbol, currency);
+    assert(tokenPrice !== undefined);
+    return [tokenPrice.timestamp.toString(), tokenPrice.price];
+  }
+
   // Return an array of spot prices for an array of collateral addresses in one async call. Note we might in future
   // This was adapted from packages/merkle-distributor/kpi-options-helpers/calculate-uma-tvl.ts
   async getContractPrices(
@@ -381,6 +412,11 @@ export class Coingecko {
     return this.prices[platform_id][currency];
   }
 
+  protected getPriceCacheBySymbol(symbol: string): { [currency: string]: Omit<CoinGeckoPrice, "address"> } {
+    if (this.pricesBySymbol[symbol] === undefined) this.pricesBySymbol[symbol] = {};
+    return this.pricesBySymbol[symbol];
+  }
+
   protected getCachedAddressPrice(
     contractAddress: string,
     currency: string,
@@ -409,6 +445,16 @@ export class Coingecko {
     }
   }
 
+  protected getCachedSymbolPrice(symbol: string, currency: string): Omit<CoinGeckoPrice, "address"> | undefined {
+    const priceCache = this.getPriceCacheBySymbol(symbol);
+    const now: number = msToS(Date.now());
+    const tokenPrice: Omit<CoinGeckoPrice, "address"> | undefined = priceCache[currency];
+    if (tokenPrice === undefined || tokenPrice.timestamp + this.maxPriceAge <= now) {
+      return undefined;
+    }
+    return tokenPrice;
+  }
+
   protected updatePriceCache(cgPrice: CGTokenPrice, contractAddress: string, currency: string, platform_id: string) {
     const priceCache = this.getPriceCache(currency, platform_id);
     if (priceCache[contractAddress] === undefined) {
@@ -433,6 +479,29 @@ export class Coingecko {
     }
   }
 
+  protected updatePriceCacheBySymbol(cgPrice: CGTokenPrice, symbol: string, currency: string) {
+    const priceCache = this.getPriceCacheBySymbol(symbol);
+    if (priceCache[currency] === undefined) {
+      priceCache[currency] = { price: 0, timestamp: 0 };
+    }
+    if (cgPrice.last_updated_at > priceCache[currency].timestamp) {
+      priceCache[currency] = {
+        price: cgPrice[currency],
+        timestamp: cgPrice.last_updated_at,
+      };
+      this.logger.debug({
+        at: "Coingecko#updatePriceCacheBySymbol",
+        message: `Updated ${symbol}/${currency} token price cache.`,
+      });
+    } else {
+      this.logger.debug({
+        at: "Coingecko#updatePriceCacheBySymbol",
+        message: `No new price available for symbol ${symbol}.`,
+        token: cgPrice,
+      });
+    }
+  }
+
   private async _callBasic(path: string, timeout?: number) {
     const url = `${this.host}/${path}`;