feat: modify gas oracle TS tooling to be friendly for all protocol types

typescript/cli/src/config/hooks.ts

@@ -221,6 +221,7 @@ export const createIGPConfig = callWithConfigCreationLogs(
     // Calculate storage gas oracle config
     const oracleConfig = getLocalStorageGasOracleConfig({
       local: localChain,
+      localProtocolType: context.multiProvider.getProtocol(localChain),
       gasOracleParams: prices,
       exchangeRateMarginPct,
     });

typescript/infra/config/environments/mainnet3/igp.ts

@@ -4,22 +4,19 @@ import {
   ChainTechnicalStack,
   HookType,
   IgpConfig,
-  getTokenExchangeRateFromValues,
 } from '@hyperlane-xyz/sdk';
 import { exclude, objMap } from '@hyperlane-xyz/utils';
 
 import {
   AllStorageGasOracleConfigs,
-  EXCHANGE_RATE_MARGIN_PCT,
   getAllStorageGasOracleConfigs,
   getOverhead,
 } from '../../../src/config/gas-oracle.js';
-import { mustGetChainNativeToken } from '../../../src/utils/utils.js';
 import { getChain } from '../../registry.js';
 
 import { ethereumChainNames } from './chains.js';
 import gasPrices from './gasPrices.json';
-import { DEPLOYER, ethereumChainOwners } from './owners.js';
+import { DEPLOYER, chainOwners } from './owners.js';
 import { supportedChainNames } from './supportedChainNames.js';
 import rawTokenPrices from './tokenPrices.json';
 
@@ -42,24 +39,14 @@ export function getOverheadWithOverrides(local: ChainName, remote: ChainName) {
 const storageGasOracleConfig: AllStorageGasOracleConfigs =
   getAllStorageGasOracleConfigs(
     supportedChainNames,
+    tokenPrices,
     gasPrices,
-    (local, remote) =>
-      getTokenExchangeRateFromValues({
-        local,
-        remote,
-        tokenPrices,
-        exchangeRateMarginPct: EXCHANGE_RATE_MARGIN_PCT,
-        decimals: {
-          local: mustGetChainNativeToken(local).decimals,
-          remote: mustGetChainNativeToken(remote).decimals,
-        },
-      }),
-    (local) => parseFloat(tokenPrices[local]),
     (local, remote) => getOverheadWithOverrides(local, remote),
+    true,
   );
 
 export const igp: ChainMap<IgpConfig> = objMap(
-  ethereumChainOwners,
+  chainOwners,
   (local, owner): IgpConfig => ({
     type: HookType.INTERCHAIN_GAS_PAYMASTER,
     ...owner,

typescript/infra/config/environments/test/gas-oracle.ts

@@ -1,11 +1,4 @@
-import { BigNumber, ethers } from 'ethers';
-
-import {
-  ChainMap,
-  ChainName,
-  GasPriceConfig,
-  TOKEN_EXCHANGE_RATE_DECIMALS,
-} from '@hyperlane-xyz/sdk';
+import { ChainMap, GasPriceConfig } from '@hyperlane-xyz/sdk';
 
 import {
   AllStorageGasOracleConfigs,
@@ -14,31 +7,29 @@ import {
 
 import { testChainNames } from './chains.js';
 
-const TEST_TOKEN_EXCHANGE_RATE = ethers.utils.parseUnits(
-  '1',
-  TOKEN_EXCHANGE_RATE_DECIMALS,
-);
+const TEST_TOKEN_EXCHANGE_RATE = '1';
 const TEST_GAS_PRICE_CONFIG: GasPriceConfig = {
   amount: '2',
   decimals: 9, // gwei
 };
 
+const tokenPrices: ChainMap<string> = {
+  test1: TEST_TOKEN_EXCHANGE_RATE,
+  test2: TEST_TOKEN_EXCHANGE_RATE,
+  test3: TEST_TOKEN_EXCHANGE_RATE,
+};
+
 const gasPrices: ChainMap<GasPriceConfig> = {
   test1: TEST_GAS_PRICE_CONFIG,
   test2: TEST_GAS_PRICE_CONFIG,
   test3: TEST_GAS_PRICE_CONFIG,
 };
 
-function getTokenExchangeRate(
-  _local: ChainName,
-  _remote: ChainName,
-): BigNumber {
-  return TEST_TOKEN_EXCHANGE_RATE;
-}
-
 export const storageGasOracleConfig: AllStorageGasOracleConfigs =
   getAllStorageGasOracleConfigs(
     testChainNames,
+    tokenPrices,
     gasPrices,
-    getTokenExchangeRate,
+    (_local, _remote) => 0,
+    false,
   );

typescript/infra/config/environments/testnet4/gasPrices.json

@@ -96,7 +96,7 @@
     "decimals": 9
   },
   "solanatestnet": {
-    "amount": "0.0001",
+    "amount": "0.01",
     "decimals": 1
   },
   "soneiumtestnet": {
@@ -108,7 +108,7 @@
     "decimals": 9
   },
   "sonicsvmtestnet": {
-    "amount": "0.0001",
+    "amount": "0.01",
     "decimals": 1
   },
   "suavetoliman": {

typescript/infra/config/environments/testnet4/igp.ts

@@ -1,18 +1,11 @@
-import {
-  ChainMap,
-  HookType,
-  IgpConfig,
-  getTokenExchangeRateFromValues,
-} from '@hyperlane-xyz/sdk';
+import { ChainMap, HookType, IgpConfig } from '@hyperlane-xyz/sdk';
 import { Address, exclude, objMap } from '@hyperlane-xyz/utils';
 
 import {
   AllStorageGasOracleConfigs,
-  EXCHANGE_RATE_MARGIN_PCT,
   getAllStorageGasOracleConfigs,
   getOverhead,
 } from '../../../src/config/gas-oracle.js';
-import { mustGetChainNativeToken } from '../../../src/utils/utils.js';
 
 import { ethereumChainNames } from './chains.js';
 import gasPrices from './gasPrices.json';
@@ -25,18 +18,10 @@ const tokenPrices: ChainMap<string> = rawTokenPrices;
 export const storageGasOracleConfig: AllStorageGasOracleConfigs =
   getAllStorageGasOracleConfigs(
     supportedChainNames,
+    tokenPrices,
     gasPrices,
-    (local, remote) =>
-      getTokenExchangeRateFromValues({
-        local,
-        remote,
-        tokenPrices,
-        exchangeRateMarginPct: EXCHANGE_RATE_MARGIN_PCT,
-        decimals: {
-          local: mustGetChainNativeToken(local).decimals,
-          remote: mustGetChainNativeToken(remote).decimals,
-        },
-      }),
+    (local, remote) => getOverhead(local, remote, ethereumChainNames),
+    false,
   );
 
 export const igp: ChainMap<IgpConfig> = objMap(

typescript/infra/config/environments/testnet4/tokenPrices.json

@@ -25,6 +25,7 @@
   "sepolia": "10",
   "solanatestnet": "10",
   "soneiumtestnet": "10",
+  "sonictestnet": "10",
   "sonicblaze": "10",
   "sonicsvmtestnet": "10",
   "suavetoliman": "10",

typescript/infra/config/registry.ts

@@ -104,7 +104,9 @@ export function getWarpCoreConfig(warpRouteId: string): WarpCoreConfig {
   return warpRouteConfig;
 }
 
-export function getWarpAddresses(warpRouteId: string) {
+export function getWarpAddresses(
+  warpRouteId: string,
+): ChainMap<ChainAddresses> {
   const warpCoreConfig = getWarpCoreConfig(warpRouteId);
   return warpConfigToWarpAddresses(warpCoreConfig);
 }

typescript/infra/scripts/agent-utils.ts

@@ -177,6 +177,13 @@ export function withChainsRequired<T>(
   return withChains(args, chainOptions).demandOption('chains');
 }
 
+export function withOutputFile<T>(args: Argv<T>) {
+  return args
+    .describe('outFile', 'output file')
+    .string('outFile')
+    .alias('o', 'outFile');
+}
+
 export function withWarpRouteId<T>(args: Argv<T>) {
   return args.describe('warpRouteId', 'warp route id').string('warpRouteId');
 }

typescript/infra/scripts/sealevel-helpers/print-gas-oracles.ts

@@ -0,0 +1,131 @@
+import {
+  ChainMap,
+  ChainName,
+  ProtocolAgnositicGasOracleConfig,
+} from '@hyperlane-xyz/sdk';
+import {
+  ProtocolType,
+  objFilter,
+  objMap,
+  stringifyObject,
+} from '@hyperlane-xyz/utils';
+
+import { WarpRouteIds } from '../../config/environments/mainnet3/warp/warpIds.js';
+import { getChain, getWarpAddresses } from '../../config/registry.js';
+import { DeployEnvironment } from '../../src/config/environment.js';
+import { writeJsonAtPath } from '../../src/utils/utils.js';
+import { getArgs, withOutputFile } from '../agent-utils.js';
+import { getEnvironmentConfig } from '../core-utils.js';
+
+// This script exists to print the gas oracle configs for a given environment
+// so they can easily be copied into the Sealevel tooling. :'(
+
+interface GasOracleConfigWithOverhead {
+  oracleConfig: ProtocolAgnositicGasOracleConfig;
+  overhead?: number;
+}
+
+async function main() {
+  const { environment, outFile } = await withOutputFile(getArgs()).argv;
+
+  const environmentConfig = getEnvironmentConfig(environment);
+
+  const allConnectedChains = getChainConnections(environment);
+
+  // Construct a nested map of origin -> destination -> { oracleConfig, overhead }
+  let gasOracles = objMap(environmentConfig.igp, (origin, igpConfig) => {
+    // Only SVM origins for now
+    if (getChain(origin).protocol !== ProtocolType.Sealevel) {
+      return undefined;
+    }
+
+    // If there's no oracle config, don't do anything for this origin
+    if (!igpConfig.oracleConfig) {
+      return undefined;
+    }
+    // Get the set of chains that are connected to this origin via warp routes
+    const connectedChainsSet = allConnectedChains[origin];
+    if (!connectedChainsSet) {
+      return undefined;
+    }
+    const connectedChains = [...connectedChainsSet];
+
+    return connectedChains.reduce((agg, destination) => {
+      const oracleConfig = igpConfig.oracleConfig[destination];
+      if (oracleConfig.tokenDecimals === undefined) {
+        throw new Error(
+          `Token decimals not defined for ${origin} -> ${destination}`,
+        );
+      }
+      agg[destination] = {
+        oracleConfig,
+        overhead: igpConfig?.overhead?.[destination],
+      };
+      return agg;
+    }, {} as ChainMap<GasOracleConfigWithOverhead>);
+  });
+
+  // Filter out undefined values
+  gasOracles = objFilter(
+    gasOracles,
+    (_, value): value is ChainMap<GasOracleConfigWithOverhead> | undefined =>
+      value !== undefined,
+  );
+
+  console.log(stringifyObject(gasOracles, 'json', 2));
+
+  if (outFile) {
+    console.log(`Writing config to ${outFile}`);
+    writeJsonAtPath(outFile, gasOracles);
+  }
+}
+
+// Gets the chains in the provided warp route
+function getWarpChains(warpRouteId: string): ChainName[] {
+  const warpRouteAddresses = getWarpAddresses(warpRouteId);
+  return Object.keys(warpRouteAddresses);
+}
+
+// Because there is a limit to how many chains we want to figure in an SVM IGP,
+// we limit the chains to only those that are connected via warp routes.
+// Returns a record of origin chain -> set of chains that are connected via warp routes.
+function getChainConnections(
+  environment: DeployEnvironment,
+): ChainMap<Set<ChainName>> {
+  // A list of connected chains
+  let connectedChains = [];
+
+  if (environment === 'mainnet3') {
+    // All the mainnet3 warp route chains
+    connectedChains = Object.values(WarpRouteIds).map(getWarpChains);
+  } else if (environment === 'testnet4') {
+    connectedChains = [
+      // As testnet warp routes are not tracked well, hardcode the connected chains.
+      // For SOL/solanatestnet-sonicsvmtestnet
+      ['solanatestnet', 'sonicsvmtestnet'],
+    ];
+  } else {
+    throw new Error(`Unknown environment: ${environment}`);
+  }
+
+  return connectedChains.reduce((agg, chains) => {
+    // Make sure each chain is connected to every other chain
+    chains.forEach((chainA) => {
+      chains.forEach((chainB) => {
+        if (chainA === chainB) {
+          return;
+        }
+        if (agg[chainA] === undefined) {
+          agg[chainA] = new Set();
+        }
+        agg[chainA].add(chainB as ChainName);
+      });
+    });
+    return agg;
+  }, {} as ChainMap<Set<ChainName>>);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

typescript/infra/scripts/sealevel-helpers/print-multisig-ism-config.ts

@@ -39,8 +39,6 @@ async function main() {
     }
   }
 
-  console.warn;
-
   console.log(JSON.stringify(config, null, 2));
 }
 

typescript/infra/scripts/warp-routes/generate-warp-config.ts

@@ -4,15 +4,17 @@ import { WarpRouteDeployConfigSchema } from '@hyperlane-xyz/sdk';
 
 import { getWarpConfig } from '../../config/warp.js';
 import { writeYamlAtPath } from '../../src/utils/utils.js';
-import { getArgs, withWarpRouteIdRequired } from '../agent-utils.js';
+import {
+  getArgs,
+  withOutputFile,
+  withWarpRouteIdRequired,
+} from '../agent-utils.js';
 import { getEnvironmentConfig, getHyperlaneCore } from '../core-utils.js';
 
 async function main() {
-  const { warpRouteId, environment, outFile } = await withWarpRouteIdRequired(
-    getArgs(),
-  )
-    .string('outFile')
-    .describe('outFile', 'The file to write the config to').argv;
+  const { warpRouteId, environment, outFile } = await withOutputFile(
+    withWarpRouteIdRequired(getArgs()),
+  ).argv;
 
   const { multiProvider } = await getHyperlaneCore(environment);
   const envConfig = getEnvironmentConfig(environment);