@humanode-hyperlane/rebalancer 0.0.0-stage → 27.2.2

package/src/test/helpers.ts

@@ -0,0 +1,477 @@
+import { type PopulatedTransaction, ethers, type providers } from 'ethers';
+import Sinon from 'sinon';
+
+import {
+  type ChainMap,
+  type ChainMetadata,
+  type ChainName,
+  EvmMovableCollateralAdapter,
+  type InterchainGasQuote,
+  type MultiProvider,
+  type Token,
+  type TokenAmount,
+  type WarpCore,
+} from '@humanode-hyperlane/sdk';
+
+import type { RebalancerConfig } from '../config/RebalancerConfig.js';
+import { RebalancerStrategyOptions } from '../config/types.js';
+import type {
+  ExecutionResult,
+  IRebalancer,
+  MovableCollateralExecutionResult,
+  PreparedTransaction,
+  RebalancerType,
+} from '../interfaces/IRebalancer.js';
+import type {
+  MovableCollateralRoute,
+  StrategyRoute,
+} from '../interfaces/IStrategy.js';
+import type { BridgeConfigWithOverride } from '../utils/bridgeUtils.js';
+
+// === Mock Classes ===
+
+export class MockRebalancer implements IRebalancer {
+  readonly rebalancerType: RebalancerType = 'movableCollateral';
+
+  rebalance(_routes: MovableCollateralRoute[]): Promise<ExecutionResult[]> {
+    return Promise.resolve([]);
+  }
+}
+
+// === Test Data Builders ===
+
+export function buildTestRoute(
+  overrides: Partial<StrategyRoute> = {},
+  executionType: 'movableCollateral' | 'inventory' = 'movableCollateral',
+): StrategyRoute {
+  if (executionType === 'inventory') {
+    return {
+      origin: 'ethereum',
+      destination: 'arbitrum',
+      amount: ethers.utils.parseEther('100').toBigInt(),
+      executionType: 'inventory',
+      externalBridge: 'lifi',
+      ...overrides,
+    } as StrategyRoute;
+  }
+  return {
+    origin: 'ethereum',
+    destination: 'arbitrum',
+    amount: ethers.utils.parseEther('100').toBigInt(),
+    executionType: 'movableCollateral',
+    bridge: TEST_ADDRESSES.bridge,
+    ...overrides,
+  } as StrategyRoute;
+}
+
+export function buildTestMovableCollateralRoute(
+  overrides: Partial<MovableCollateralRoute> = {},
+): MovableCollateralRoute {
+  return {
+    origin: 'ethereum',
+    destination: 'arbitrum',
+    amount: ethers.utils.parseEther('100').toBigInt(),
+    executionType: 'movableCollateral',
+    bridge: TEST_ADDRESSES.bridge,
+    ...overrides,
+  };
+}
+
+export function buildTestResult(
+  overrides: Partial<MovableCollateralExecutionResult> = {},
+): MovableCollateralExecutionResult {
+  const route = overrides.route ?? buildTestMovableCollateralRoute();
+  return {
+    route,
+    success: true,
+    messageId:
+      '0x1111111111111111111111111111111111111111111111111111111111111111',
+    txHash:
+      '0x2222222222222222222222222222222222222222222222222222222222222222',
+    ...overrides,
+  };
+}
+
+export function buildTestPreparedTransaction(
+  overrides: Partial<PreparedTransaction> = {},
+): PreparedTransaction {
+  const route =
+    overrides.route ??
+    ({
+      ...buildTestMovableCollateralRoute(),
+      intentId: 'test-intent',
+    } as MovableCollateralRoute & { intentId: string });
+  return {
+    populatedTx: {
+      to: TEST_ADDRESSES.token,
+      data: '0x',
+      value: ethers.BigNumber.from(0),
+    } as PopulatedTransaction,
+    route,
+    originTokenAmount: createMockTokenAmount(route.amount),
+    ...overrides,
+  };
+}
+
+// === Mock Factories ===
+
+export function createMockTokenAmount(amount: bigint): TokenAmount {
+  return {
+    amount,
+    token: {
+      name: 'TestToken',
+      symbol: 'TEST',
+      decimals: 18,
+      addressOrDenom: TEST_ADDRESSES.token,
+    },
+    getDecimalFormattedAmount: () => ethers.utils.formatEther(amount),
+  } as unknown as TokenAmount;
+}
+
+export interface MockAdapterConfig {
+  isRebalancer?: boolean;
+  allowedDestination?: string;
+  isBridgeAllowed?: boolean;
+  quotes?: InterchainGasQuote[];
+  populatedTx?: PopulatedTransaction;
+  throwOnQuotes?: Error;
+  throwOnPopulate?: Error;
+}
+
+export function createMockAdapter(config: MockAdapterConfig = {}) {
+  const {
+    isRebalancer = true,
+    allowedDestination = TEST_ADDRESSES.arbitrum,
+    isBridgeAllowed = true,
+    quotes = [{ igpQuote: { amount: BigInt(1000000) } }],
+    populatedTx = {
+      to: TEST_ADDRESSES.token,
+      data: '0x',
+      value: ethers.BigNumber.from(0),
+    },
+    throwOnQuotes,
+    throwOnPopulate,
+  } = config;
+
+  const adapter = {
+    isRebalancer: Sinon.stub().resolves(isRebalancer),
+    getAllowedDestination: Sinon.stub().resolves(allowedDestination),
+    isBridgeAllowed: Sinon.stub().resolves(isBridgeAllowed),
+    getRebalanceQuotes: throwOnQuotes
+      ? Sinon.stub().rejects(throwOnQuotes)
+      : Sinon.stub().resolves(quotes),
+    populateRebalanceTx: throwOnPopulate
+      ? Sinon.stub().rejects(throwOnPopulate)
+      : Sinon.stub().resolves(populatedTx),
+  };
+
+  Object.setPrototypeOf(adapter, EvmMovableCollateralAdapter.prototype);
+  return adapter;
+}
+
+export interface MockTokenConfig {
+  name?: string;
+  decimals?: number;
+  addressOrDenom?: string;
+  adapter?: ReturnType<typeof createMockAdapter>;
+}
+
+export function createMockToken(config: MockTokenConfig = {}) {
+  const {
+    name = 'TestToken',
+    decimals = 18,
+    addressOrDenom = TEST_ADDRESSES.token,
+    adapter = createMockAdapter(),
+  } = config;
+
+  const token = {
+    name,
+    decimals,
+    addressOrDenom,
+    amount: (amt: bigint) => createMockTokenAmount(amt),
+    getHypAdapter: Sinon.stub().returns(adapter),
+  };
+
+  return { token, adapter };
+}
+
+export interface MockMultiProviderConfig {
+  chainMetadata?: ChainMap<Partial<ChainMetadata>>;
+  signerAddress?: string;
+  sendTransactionReceipt?: providers.TransactionReceipt;
+  throwOnSendTransaction?: Error;
+  throwOnEstimateGas?: Error;
+  providerWaitForTransaction?: providers.TransactionReceipt;
+  providerGetBlock?: providers.Block | null;
+  providerGetTransactionReceipt?: providers.TransactionReceipt | null;
+}
+
+export function createMockMultiProvider(config: MockMultiProviderConfig = {}) {
+  const {
+    chainMetadata = {},
+    signerAddress = TEST_ADDRESSES.signer,
+    sendTransactionReceipt = {
+      transactionHash:
+        '0x1111111111111111111111111111111111111111111111111111111111111111',
+      blockNumber: 100,
+      status: 1,
+    } as providers.TransactionReceipt,
+    throwOnSendTransaction,
+    throwOnEstimateGas,
+    providerWaitForTransaction = sendTransactionReceipt,
+    providerGetBlock = { number: 150 } as providers.Block,
+    providerGetTransactionReceipt = sendTransactionReceipt,
+  } = config;
+
+  const mockProvider = {
+    waitForTransaction: Sinon.stub().resolves(providerWaitForTransaction),
+    getBlock: Sinon.stub().resolves(providerGetBlock),
+    getTransactionReceipt: Sinon.stub().resolves(providerGetTransactionReceipt),
+  };
+
+  const mockSigner = {
+    getAddress: Sinon.stub().resolves(signerAddress),
+    sendTransaction: throwOnSendTransaction
+      ? Sinon.stub().rejects(throwOnSendTransaction)
+      : Sinon.stub().resolves({
+          hash: sendTransactionReceipt.transactionHash,
+          wait: Sinon.stub().resolves(sendTransactionReceipt),
+        }),
+  };
+
+  const defaultChainMetadata: ChainMap<Partial<ChainMetadata>> = {
+    ethereum: { domainId: 1, blocks: { confirmations: 32, reorgPeriod: 32 } },
+    arbitrum: {
+      domainId: 42161,
+      blocks: { confirmations: 0, reorgPeriod: 0, estimateBlockTime: 1 },
+    },
+  };
+
+  const mergedMetadata = { ...defaultChainMetadata, ...chainMetadata };
+
+  return {
+    getChainMetadata: Sinon.stub().callsFake(
+      (chain: ChainName) => mergedMetadata[chain] ?? {},
+    ),
+    getProvider: Sinon.stub().returns(mockProvider),
+    getSigner: Sinon.stub().returns(mockSigner),
+    estimateGas: throwOnEstimateGas
+      ? Sinon.stub().rejects(throwOnEstimateGas)
+      : Sinon.stub().resolves(ethers.BigNumber.from(100000)),
+    sendTransaction: throwOnSendTransaction
+      ? Sinon.stub().rejects(throwOnSendTransaction)
+      : Sinon.stub().resolves(sendTransactionReceipt),
+    getDomainId: Sinon.stub().callsFake(
+      (chain: ChainName) => mergedMetadata[chain]?.domainId ?? 0,
+    ),
+    _mockProvider: mockProvider,
+    _mockSigner: mockSigner,
+  } as unknown as MultiProvider & {
+    _mockProvider: typeof mockProvider;
+    _mockSigner: typeof mockSigner;
+  };
+}
+
+export function createMockWarpCore(multiProvider: MultiProvider) {
+  return {
+    multiProvider,
+  } as unknown as WarpCore;
+}
+
+// Valid EVM test addresses (40 hex chars after 0x)
+export const TEST_ADDRESSES: Record<string, string> = {
+  ethereum: '0x1111111111111111111111111111111111111111',
+  arbitrum: '0x2222222222222222222222222222222222222222',
+  optimism: '0x3333333333333333333333333333333333333333',
+  polygon: '0x4444444444444444444444444444444444444444',
+  bridge: '0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB',
+  signer: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  token: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+};
+
+export function getTestAddress(key: string): string {
+  return TEST_ADDRESSES[key] ?? `0x${key.padStart(40, '0').slice(-40)}`;
+}
+
+export function buildTestBridges(
+  chains: ChainName[] = ['ethereum', 'arbitrum'],
+): ChainMap<BridgeConfigWithOverride> {
+  return chains.reduce((acc, chain) => {
+    acc[chain] = {
+      executionType: 'movableCollateral',
+      bridge: TEST_ADDRESSES.bridge,
+      bridgeMinAcceptedAmount: 0,
+    };
+    return acc;
+  }, {} as ChainMap<BridgeConfigWithOverride>);
+}
+
+/**
+ * Convert a chain config map (with bridge addresses) to a BridgeConfigWithOverride map.
+ * Useful for tests that define bridge addresses in the strategy config.
+ */
+export function extractBridgeConfigs(
+  chainConfig: Record<
+    string,
+    { bridge: string; bridgeMinAcceptedAmount?: number | string }
+  >,
+): ChainMap<BridgeConfigWithOverride> {
+  return Object.entries(chainConfig).reduce((acc, [chain, config]) => {
+    acc[chain] = {
+      executionType: 'movableCollateral',
+      bridge: config.bridge,
+      bridgeMinAcceptedAmount: config.bridgeMinAcceptedAmount ?? 0,
+    };
+    return acc;
+  }, {} as ChainMap<BridgeConfigWithOverride>);
+}
+
+export function buildTestChainMetadata(
+  chains: ChainName[] = ['ethereum', 'arbitrum'],
+): ChainMap<ChainMetadata> {
+  const domainIds: Record<string, number> = {
+    ethereum: 1,
+    arbitrum: 42161,
+    optimism: 10,
+    polygon: 137,
+  };
+
+  return chains.reduce((acc, chain) => {
+    acc[chain] = {
+      name: chain,
+      chainId: domainIds[chain] ?? 1,
+      domainId: domainIds[chain] ?? 1,
+      protocol: 'ethereum' as any,
+      rpcUrls: [{ http: 'http://localhost:8545' }],
+      blocks: { reorgPeriod: chain === 'polygon' ? 'finalized' : 32 },
+    } as ChainMetadata;
+    return acc;
+  }, {} as ChainMap<ChainMetadata>);
+}
+
+export interface RebalancerTestContext {
+  multiProvider: ReturnType<typeof createMockMultiProvider>;
+  warpCore: WarpCore;
+  bridges: ChainMap<BridgeConfigWithOverride>;
+  chainMetadata: ChainMap<ChainMetadata>;
+  tokensByChainName: ChainMap<Token>;
+  adapters: ChainMap<ReturnType<typeof createMockAdapter>>;
+}
+
+export function createRebalancerTestContext(
+  chains: ChainName[] = ['ethereum', 'arbitrum'],
+  adapterConfigs: ChainMap<MockAdapterConfig> = {},
+): RebalancerTestContext {
+  const multiProvider = createMockMultiProvider();
+  const warpCore = createMockWarpCore(
+    multiProvider as unknown as MultiProvider,
+  );
+  const bridges = buildTestBridges(chains);
+  const chainMetadata = buildTestChainMetadata(chains);
+
+  const adapters: ChainMap<ReturnType<typeof createMockAdapter>> = {};
+  const tokensByChainName: ChainMap<Token> = {};
+
+  for (const chain of chains) {
+    const adapterConfig = adapterConfigs[chain] ?? {};
+    const tokenAddress = getTestAddress(chain);
+    const { token, adapter } = createMockToken({
+      name: `${chain}Token`,
+      addressOrDenom: tokenAddress,
+      adapter: createMockAdapter(adapterConfig),
+    });
+    adapters[chain] = adapter;
+    tokensByChainName[chain] = token as unknown as Token;
+  }
+
+  for (const originChain of chains) {
+    const adapterConfig = adapterConfigs[originChain] ?? {};
+    if (adapterConfig.allowedDestination === undefined) {
+      const destAddressMap: Record<number, string> = {};
+      for (const destChain of chains) {
+        if (originChain !== destChain) {
+          destAddressMap[chainMetadata[destChain].domainId] =
+            getTestAddress(destChain);
+        }
+      }
+      adapters[originChain].getAllowedDestination.callsFake(
+        (domainId: number) => {
+          return Promise.resolve(
+            destAddressMap[domainId] ??
+              '0x0000000000000000000000000000000000000000',
+          );
+        },
+      );
+    }
+  }
+
+  return {
+    multiProvider,
+    warpCore,
+    bridges,
+    chainMetadata,
+    tokensByChainName,
+    adapters,
+  };
+}
+
+// === Config Builders ===
+
+export function buildTestConfig(
+  overrides: Partial<RebalancerConfig> = {},
+  chains: string[] = ['chain1'],
+): RebalancerConfig {
+  const baseChains = chains.reduce(
+    (acc, chain) => {
+      (acc as any)[chain] = {
+        bridgeLockTime: 60 * 1000,
+        bridge: ethers.constants.AddressZero,
+        weighted: {
+          weight: BigInt(1),
+          tolerance: BigInt(0),
+        },
+      };
+      return acc;
+    },
+    {} as Record<string, any>,
+  );
+
+  // Build the default strategy config
+  const defaultStrategyConfig = {
+    rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+    chains: baseChains,
+  };
+
+  // If overrides has strategyConfig as an array, use it directly
+  // Otherwise, wrap single strategy in an array
+  let strategyConfig;
+  if (overrides.strategyConfig) {
+    if (Array.isArray(overrides.strategyConfig)) {
+      strategyConfig = overrides.strategyConfig;
+    } else {
+      // Single strategy override - use it directly wrapped in array
+      // If chains is explicitly provided, use it (don't merge with baseChains)
+      const singleConfig = overrides.strategyConfig as any;
+      strategyConfig = [
+        {
+          ...singleConfig,
+          chains:
+            singleConfig.chains !== undefined
+              ? singleConfig.chains
+              : baseChains,
+        },
+      ];
+    }
+  } else {
+    strategyConfig = [defaultStrategyConfig];
+  }
+
+  // Destructure to exclude strategyConfig from overrides spread
+  const { strategyConfig: _, ...restOverrides } = overrides;
+
+  return {
+    warpRouteId: 'test-route',
+    ...restOverrides,
+    strategyConfig,
+  } as any as RebalancerConfig;
+}

package/src/test/lifiMocks.ts

@@ -0,0 +1,211 @@
+import Sinon, { type SinonStub } from 'sinon';
+
+import type {
+  BridgeQuote,
+  BridgeQuoteParams,
+  BridgeTransferStatus,
+} from '../interfaces/IExternalBridge.js';
+
+/**
+ * Create mock functions for LiFi SDK.
+ */
+export function createLiFiSdkMocks() {
+  return {
+    createConfig: Sinon.stub(),
+    getQuote: Sinon.stub(),
+    executeRoute: Sinon.stub(),
+    getStatus: Sinon.stub(),
+    convertQuoteToRoute: Sinon.stub().callsFake((quote: unknown) => {
+      const q = quote as Record<string, unknown> & {
+        action?: { fromChainId?: number; toChainId?: number };
+      };
+      return {
+        ...q,
+        fromChainId: q.action?.fromChainId ?? 42161,
+        toChainId: q.action?.toChainId ?? 1151111081099710,
+        steps: [],
+      };
+    }),
+  };
+}
+
+/**
+ * Configure a mock getQuote to return a successful quote.
+ */
+export function mockSuccessfulQuote(
+  stub: SinonStub,
+  overrides?: Partial<{
+    id: string;
+    tool: string;
+    fromAmount: string;
+    toAmount: string;
+    toAmountMin: string;
+    executionDuration: number;
+    fromChainId: number;
+    toChainId: number;
+  }>,
+) {
+  const fromChainId = overrides?.fromChainId ?? 42161;
+  const toChainId = overrides?.toChainId ?? 1151111081099710;
+  const fromAmount = overrides?.fromAmount ?? '10000000000';
+  const toAmount = overrides?.toAmount ?? '9950000000';
+  const toAmountMin = overrides?.toAmountMin ?? '9900000000';
+
+  stub.resolves({
+    id: overrides?.id ?? 'quote-123',
+    tool: overrides?.tool ?? 'across',
+    action: {
+      fromAmount,
+      fromChainId,
+      toChainId,
+    },
+    estimate: {
+      toAmount,
+      toAmountMin,
+      executionDuration: overrides?.executionDuration ?? 300,
+    },
+  });
+}
+
+/**
+ * Configure a mock executeRoute to return a successful execution.
+ */
+export function mockSuccessfulExecution(stub: SinonStub, txHash: string) {
+  stub.resolves({
+    steps: [
+      {
+        execution: {
+          process: [{ txHash }],
+        },
+      },
+    ],
+  });
+}
+
+/**
+ * Configure a mock getStatus to return a specific status.
+ */
+export function mockLiFiStatus(
+  stub: SinonStub,
+  status: 'DONE' | 'PENDING' | 'FAILED' | 'NOT_FOUND',
+  overrides?: Partial<{
+    receivingTxHash: string;
+    amount: string;
+    substatus: string;
+  }>,
+) {
+  const responses: Record<string, unknown> = {
+    DONE: {
+      status: 'DONE',
+      receiving: {
+        txHash: overrides?.receivingTxHash ?? '0xReceivingTxHash',
+        amount: overrides?.amount ?? '9950000000',
+      },
+    },
+    PENDING: {
+      status: 'PENDING',
+      substatus: overrides?.substatus ?? 'WAIT_SOURCE_CONFIRMATIONS',
+    },
+    FAILED: {
+      status: 'FAILED',
+      substatus: overrides?.substatus ?? 'BRIDGE_CALL_FAILED',
+    },
+    NOT_FOUND: {
+      status: 'NOT_FOUND',
+    },
+  };
+
+  stub.resolves(responses[status]);
+}
+
+/**
+ * Create a mock BridgeQuote for testing.
+ * The route structure includes all fields read by validateRouteAgainstRequest.
+ */
+export function createMockBridgeQuote(
+  overrides?: Partial<BridgeQuote>,
+): BridgeQuote {
+  const route = overrides?.route as
+    | { action?: { fromChainId?: number; toChainId?: number } }
+    | undefined;
+
+  const defaultRequestParams: BridgeQuoteParams = {
+    fromChain: 42161,
+    toChain: 1399811149,
+    fromToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+    toToken: '0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC',
+    fromAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+    toAddress: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+    fromAmount: 10000000000n,
+  };
+  const requestParams: BridgeQuoteParams = {
+    ...defaultRequestParams,
+    ...overrides?.requestParams,
+  };
+
+  const fromChainId = route?.action?.fromChainId ?? requestParams.fromChain;
+  const toChainId = route?.action?.toChainId ?? requestParams.toChain;
+  const fromAmount =
+    overrides?.fromAmount ?? requestParams.fromAmount ?? 10000000000n;
+  const toAmount = overrides?.toAmount ?? 9950000000n;
+  const toAmountMin = overrides?.toAmountMin ?? 9900000000n;
+
+  return {
+    id: 'quote-123',
+    tool: 'across',
+    fromAmount,
+    toAmount,
+    toAmountMin,
+    executionDuration: 300,
+    gasCosts: 50000000n,
+    feeCosts: 0n,
+    // Route includes all fields read by validateRouteAgainstRequest for validation compatibility
+    route: {
+      action: { fromChainId, toChainId },
+      fromChainId,
+      toChainId,
+      fromToken: { address: requestParams.fromToken },
+      toToken: { address: requestParams.toToken },
+      fromAddress: requestParams.fromAddress,
+      toAddress: requestParams.toAddress ?? requestParams.fromAddress,
+      fromAmount: fromAmount.toString(),
+      toAmount: toAmount.toString(),
+    },
+    requestParams,
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock BridgeTransferStatus for testing.
+ */
+export function createMockBridgeStatus(
+  status: 'pending' | 'complete' | 'failed' | 'not_found',
+  overrides?: Partial<{
+    substatus: string;
+    receivingTxHash: string;
+    receivedAmount: bigint;
+    error: string;
+  }>,
+): BridgeTransferStatus {
+  switch (status) {
+    case 'pending':
+      return {
+        status: 'pending',
+        substatus: overrides?.substatus,
+      };
+    case 'complete':
+      return {
+        status: 'complete',
+        receivingTxHash: overrides?.receivingTxHash ?? '0xReceivingTxHash',
+        receivedAmount: overrides?.receivedAmount ?? 9950000000n,
+      };
+    case 'failed':
+      return {
+        status: 'failed',
+        error: overrides?.error,
+      };
+    case 'not_found':
+      return { status: 'not_found' };
+  }
+}