@hyperlane-xyz/rebalancer 27.2.12 → 27.2.13

package/src/utils/balanceUtils.ts

@@ -1,12 +1,68 @@
 import { type Logger } from 'pino';
 
-import { type ChainName } from '@hyperlane-xyz/sdk';
+import {
+  type IToken,
+  alignLocalAmountToMessage,
+  messageAmountFromLocal,
+  minLocalAmountForMessage,
+  normalizeScale,
+  scalesEqual,
+  type ChainName,
+  type NormalizedScale,
+  type ScaleAlignment,
+  type Token,
+} from '@hyperlane-xyz/sdk';
+import { toWei } from '@hyperlane-xyz/utils';
 
 import { type MonitorEvent } from '../interfaces/IMonitor.js';
 import { type RawBalances } from '../interfaces/IStrategy.js';
 
 import { isCollateralizedTokenEligibleForRebalancing } from './tokenUtils.js';
 
+export function getTokenScale(token: Token): NormalizedScale {
+  return normalizeScale(token.scale);
+}
+
+export function isIdentityScale(token: Token): boolean {
+  return scalesEqual(token.scale, undefined);
+}
+
+export function normalizeToCanonical(
+  localAmount: bigint,
+  tokenOrScale: Token | IToken | NormalizedScale,
+): bigint {
+  return messageAmountFromLocal(localAmount, getScaleInput(tokenOrScale));
+}
+
+export function denormalizeToLocal(
+  canonicalAmount: bigint,
+  tokenOrScale: Token | IToken | NormalizedScale,
+): bigint {
+  // Use ceil semantics so the returned local amount always produces at least
+  // the requested canonical progress once the token router floors on outbound.
+  return minLocalAmountForMessage(canonicalAmount, getScaleInput(tokenOrScale));
+}
+
+export function alignLocalToCanonical(
+  localAmount: bigint,
+  tokenOrScale: Token | IToken | NormalizedScale,
+): ScaleAlignment {
+  return alignLocalAmountToMessage(localAmount, getScaleInput(tokenOrScale));
+}
+
+export function normalizeConfiguredAmount(
+  amount: string | number,
+  token: Token,
+): bigint {
+  return normalizeToCanonical(BigInt(toWei(amount, token.decimals)), token);
+}
+
+function getScaleInput(tokenOrScale: Token | IToken | NormalizedScale) {
+  return 'numerator' in tokenOrScale && 'denominator' in tokenOrScale
+    ? tokenOrScale
+    : tokenOrScale.scale;
+}
+
 /**
  * Returns the raw balances required by the strategies from the monitor event
  * @param chains - The chains that should be included in the raw balances (e.g. the chains in the rebalancer config)
@@ -58,7 +114,22 @@ export function getRawBalances(
       );
     }
 
-    balances[token.chainName] = bridgedSupply;
+    const normalizedBalance = normalizeToCanonical(bridgedSupply, token);
+    balances[token.chainName] = normalizedBalance;
+
+    if (!isIdentityScale(token)) {
+      logger.debug(
+        {
+          context: getRawBalances.name,
+          chain: token.chainName,
+          tokenSymbol: token.symbol,
+          bridgedSupply: bridgedSupply.toString(),
+          normalizedBalance: normalizedBalance.toString(),
+          scale: getTokenScale(token),
+        },
+        'Normalized bridged supply to canonical units',
+      );
+    }
   }
 
   return balances;

package/src/utils/blockTag.ts

@@ -2,8 +2,10 @@ import type { Logger } from 'pino';
 
 import { providers } from 'ethers';
 
-import { EthJsonRpcBlockParameterTag } from '@hyperlane-xyz/sdk';
-import type { MinimalProviderRegistry } from '@hyperlane-xyz/sdk/providers/MinimalProviderRegistry';
+import {
+  EthJsonRpcBlockParameterTag,
+  type MultiProtocolProvider,
+} from '@hyperlane-xyz/sdk';
 import { ProtocolType } from '@hyperlane-xyz/utils';
 import type { ConfirmedBlockTag } from '../interfaces/IMonitor.js';
 
@@ -11,13 +13,16 @@ import type { ConfirmedBlockTag } from '../interfaces/IMonitor.js';
  * Get the confirmed block tag for a chain, accounting for reorg period.
  * Returns a block number that is safe from reorgs, or a named tag like 'finalized'.
  *
- * @param multiProvider - MinimalProviderRegistry instance
+ * @param multiProvider - Provider registry with chain metadata and ethers access
  * @param chainName - Name of the chain
  * @param logger - Optional logger for warnings
  * @returns Confirmed block tag (number, named tag, or undefined on error)
  */
 export async function getConfirmedBlockTag(
-  multiProvider: MinimalProviderRegistry,
+  multiProvider: Pick<
+    MultiProtocolProvider,
+    'getChainMetadata' | 'getEthersV5Provider'
+  >,
   chainName: string,
   logger?: Logger,
 ): Promise<ConfirmedBlockTag> {