revert

solidity/contracts/token/HypNative.sol

@@ -2,6 +2,7 @@
 pragma solidity >=0.8.0;
 
 import {TokenRouter} from "./libs/TokenRouter.sol";
+import {TokenMessage} from "./libs/TokenMessage.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
 /**
@@ -22,8 +23,8 @@ contract HypNative is TokenRouter {
     /**
      * @notice Initializes the Hyperlane router
      * @param _hook The post-dispatch hook contract.
-     *    @param _interchainSecurityModule The interchain security module contract.
-     *    @param _owner The this contract.
+       @param _interchainSecurityModule The interchain security module contract.
+       @param _owner The this contract.
      */
     function initialize(
         address _hook,

solidity/test/isms/ExternalBridgeTest.sol

@@ -115,6 +115,7 @@ abstract contract ExternalBridgeTest is Test {
     function test_postDispatch_revertWhen_insufficientValue() public {
         bytes memory encodedHookData = _encodeHookData(messageId, 0);
         originMailbox.updateLatestDispatchedId(messageId);
+        _expectOriginExternalBridgeCall(encodedHookData);
 
         uint256 quote = hook.quoteDispatch(testMetadata, encodedMessage);
 

solidity/test/isms/OPL2ToL1Ism.t.sol

@@ -21,9 +21,7 @@ contract OPL2ToL1IsmTest is ExternalBridgeTest {
         0x4200000000000000000000000000000000000007;
 
     uint256 internal constant MOCK_NONCE = 0;
-    uint256 internal constant GAS_LIMIT = 300_000;
-    uint256 internal constant GAS_PRICE = 10;
-    uint256 internal constant OVERRIDE_MULTIPLIER = 2;
+
     TestInterchainGasPaymaster internal mockOverheadIgp;
     MockOptimismPortal internal portal;
     MockOptimismMessenger internal l1Messenger;
@@ -42,8 +40,6 @@ contract OPL2ToL1IsmTest is ExternalBridgeTest {
 
         deployAll();
         super.setUp();
-
-        GAS_QUOTE = GAS_LIMIT * GAS_PRICE;
     }
 
     function deployHook() public {
@@ -80,27 +76,14 @@ contract OPL2ToL1IsmTest is ExternalBridgeTest {
         _expectOriginExternalBridgeCall(encodedHookData);
 
         bytes memory igpMetadata = StandardHookMetadata.overrideGasLimit(
-            GAS_LIMIT
+            78_000
         );
 
         uint256 quote = hook.quoteDispatch(igpMetadata, encodedMessage);
-        assertEq(
-            quote,
-            mockOverheadIgp.quoteGasPayment(ORIGIN_DOMAIN, GAS_LIMIT)
-        );
+        assertEq(quote, mockOverheadIgp.quoteGasPayment(ORIGIN_DOMAIN, 78_000));
         hook.postDispatch{value: quote}(igpMetadata, encodedMessage);
     }
 
-    function test_quoteDispatch_dontOverrideGasLimit() public {
-        bytes memory igpMetadata = StandardHookMetadata.overrideGasLimit(
-            GAS_LIMIT * OVERRIDE_MULTIPLIER
-        );
-        assertEq(
-            hook.quoteDispatch(igpMetadata, encodedMessage),
-            GAS_LIMIT * GAS_PRICE * OVERRIDE_MULTIPLIER
-        );
-    }
-
     /* ============ helper functions ============ */
 
     function _expectOriginExternalBridgeCall(

solidity/test/token/HypERC20.t.sol

@@ -33,7 +33,7 @@ import {IXERC20} from "../../contracts/token/interfaces/IXERC20.sol";
 import {IFiatToken} from "../../contracts/token/interfaces/IFiatToken.sol";
 import {HypXERC20} from "../../contracts/token/extensions/HypXERC20.sol";
 import {HypFiatToken} from "../../contracts/token/extensions/HypFiatToken.sol";
-import {HypNativeCollateral} from "../../contracts/token/HypNativeCollateral.sol";
+import {HypNative} from "../../contracts/token/HypNative.sol";
 import {TokenRouter} from "../../contracts/token/libs/TokenRouter.sol";
 import {TokenMessage} from "../../contracts/token/libs/TokenMessage.sol";
 import {Message} from "../../contracts/libs/Message.sol";
@@ -623,16 +623,16 @@ contract HypFiatTokenTest is HypTokenTest {
     }
 }
 
-contract HypNativeCollateralTest is HypTokenTest {
+contract HypNativeTest is HypTokenTest {
     using TypeCasts for address;
 
-    HypNativeCollateral internal nativeToken;
+    HypNative internal nativeToken;
 
     function setUp() public override {
         super.setUp();
 
-        localToken = new HypNativeCollateral(address(localMailbox));
-        nativeToken = HypNativeCollateral(payable(address(localToken)));
+        localToken = new HypNative(address(localMailbox));
+        nativeToken = HypNative(payable(address(localToken)));
 
         nativeToken.enrollRemoteRouter(
             DESTINATION,

typescript/cli/cli.ts

@@ -19,15 +19,17 @@ import {
   overrideRegistryUriCommandOption,
   registryUriCommandOption,
   skipConfirmationOption,
+  strategyCommandOption,
 } from './src/commands/options.js';
 import { registryCommand } from './src/commands/registry.js';
 import { relayerCommand } from './src/commands/relayer.js';
 import { sendCommand } from './src/commands/send.js';
 import { statusCommand } from './src/commands/status.js';
+import { strategyCommand } from './src/commands/strategy.js';
 import { submitCommand } from './src/commands/submit.js';
 import { validatorCommand } from './src/commands/validator.js';
 import { warpCommand } from './src/commands/warp.js';
-import { contextMiddleware } from './src/context/context.js';
+import { contextMiddleware, signerMiddleware } from './src/context/context.js';
 import { configureLogger, errorRed } from './src/logger.js';
 import { checkVersion } from './src/utils/version-check.js';
 import { VERSION } from './src/version.js';
@@ -49,12 +51,14 @@ try {
     .option('key', keyCommandOption)
     .option('disableProxy', disableProxyCommandOption)
     .option('yes', skipConfirmationOption)
+    .option('strategy', strategyCommandOption)
     .global(['log', 'verbosity', 'registry', 'overrides', 'yes'])
     .middleware([
       (argv) => {
         configureLogger(argv.log as LogFormat, argv.verbosity as LogLevel);
       },
       contextMiddleware,
+      signerMiddleware,
     ])
     .command(avsCommand)
     .command(configCommand)
@@ -66,6 +70,7 @@ try {
     .command(relayerCommand)
     .command(sendCommand)
     .command(statusCommand)
+    .command(strategyCommand)
     .command(submitCommand)
     .command(validatorCommand)
     .command(warpCommand)

typescript/cli/src/commands/config.ts

@@ -3,6 +3,7 @@ import { CommandModule } from 'yargs';
 import { readChainConfigs } from '../config/chain.js';
 import { readIsmConfig } from '../config/ism.js';
 import { readMultisigConfig } from '../config/multisig.js';
+import { readChainSubmissionStrategyConfig } from '../config/strategy.js';
 import { readWarpRouteDeployConfig } from '../config/warp.js';
 import { CommandModuleWithContext } from '../context/types.js';
 import { log, logGreen } from '../logger.js';
@@ -31,6 +32,7 @@ const validateCommand: CommandModule = {
       .command(validateChainCommand)
       .command(validateIsmCommand)
       .command(validateIsmAdvancedCommand)
+      .command(validateStrategyCommand)
       .command(validateWarpCommand)
       .version(false)
       .demandCommand(),
@@ -76,6 +78,19 @@ const validateIsmAdvancedCommand: CommandModuleWithContext<{ path: string }> = {
   },
 };
 
+const validateStrategyCommand: CommandModuleWithContext<{ path: string }> = {
+  command: 'strategy',
+  describe: 'Validates a Strategy config file',
+  builder: {
+    path: inputFileCommandOption(),
+  },
+  handler: async ({ path }) => {
+    await readChainSubmissionStrategyConfig(path);
+    logGreen('Config is valid');
+    process.exit(0);
+  },
+};
+
 const validateWarpCommand: CommandModuleWithContext<{ path: string }> = {
   command: 'warp',
   describe: 'Validate a Warp Route deployment config file',

typescript/cli/src/commands/options.ts

@@ -95,6 +95,7 @@ export const DEFAULT_WARP_ROUTE_DEPLOYMENT_CONFIG_PATH =
   './configs/warp-route-deployment.yaml';
 
 export const DEFAULT_CORE_DEPLOYMENT_CONFIG_PATH = './configs/core-config.yaml';
+export const DEFAULT_STRATEGY_CONFIG_PATH = `${os.homedir()}/.hyperlane/strategies/default-strategy.yaml`;
 
 export const warpDeploymentConfigCommandOption: Options = {
   type: 'string',
@@ -196,8 +197,8 @@ export const transactionsCommandOption: Options = {
 export const strategyCommandOption: Options = {
   type: 'string',
   description: 'The submission strategy input file path.',
-  alias: 's',
-  demandOption: true,
+  alias: ['s', 'strategy'],
+  demandOption: false,
 };
 
 export const addressCommandOption = (

typescript/cli/src/commands/signCommands.ts

@@ -1,11 +1,36 @@
 // Commands that send tx and require a key to sign.
 // It's useful to have this listed here so the context
 // middleware can request keys up front when required.
-export const SIGN_COMMANDS = ['deploy', 'send', 'status', 'submit', 'relayer'];
+export const SIGN_COMMANDS = [
+  'apply',
+  'deploy',
+  'send',
+  'status',
+  'submit',
+  'relayer',
+];
 
 export function isSignCommand(argv: any): boolean {
+  //TODO: fix reading and checking warp without signer, and remove this
+  const temporarySignCommandsCheck =
+    argv._[0] === 'warp' && (argv._[1] === 'read' || argv._[1] === 'check');
   return (
     SIGN_COMMANDS.includes(argv._[0]) ||
-    (argv._.length > 1 && SIGN_COMMANDS.includes(argv._[1]))
+    (argv._.length > 1 && SIGN_COMMANDS.includes(argv._[1])) ||
+    temporarySignCommandsCheck
   );
 }
+
+export enum CommandType {
+  WARP_DEPLOY = 'warp:deploy',
+  WARP_SEND = 'warp:send',
+  WARP_APPLY = 'warp:apply',
+  WARP_READ = 'warp:read',
+  WARP_CHECK = 'warp:check',
+  SEND_MESSAGE = 'send:message',
+  AGENT_KURTOSIS = 'deploy:kurtosis-agents',
+  STATUS = 'status:',
+  SUBMIT = 'submit:',
+  RELAYER = 'relayer:',
+  CORE_APPLY = 'core:apply',
+}

typescript/cli/src/commands/strategy.ts

@@ -0,0 +1,70 @@
+import { stringify as yamlStringify } from 'yaml';
+import { CommandModule } from 'yargs';
+
+import {
+  createStrategyConfig,
+  readChainSubmissionStrategyConfig,
+} from '../config/strategy.js';
+import { CommandModuleWithWriteContext } from '../context/types.js';
+import { log, logCommandHeader } from '../logger.js';
+import { indentYamlOrJson } from '../utils/files.js';
+import { maskSensitiveData } from '../utils/output.js';
+
+import {
+  DEFAULT_STRATEGY_CONFIG_PATH,
+  outputFileCommandOption,
+  strategyCommandOption,
+} from './options.js';
+
+/**
+ * Parent command
+ */
+export const strategyCommand: CommandModule = {
+  command: 'strategy',
+  describe: 'Manage Hyperlane deployment strategies',
+  builder: (yargs) =>
+    yargs.command(init).command(read).version(false).demandCommand(),
+  handler: () => log('Command required'),
+};
+
+export const init: CommandModuleWithWriteContext<{
+  out: string;
+}> = {
+  command: 'init',
+  describe: 'Creates strategy configuration',
+  builder: {
+    out: outputFileCommandOption(DEFAULT_STRATEGY_CONFIG_PATH),
+  },
+  handler: async ({ context, out }) => {
+    logCommandHeader(`Hyperlane Strategy Init`);
+
+    await createStrategyConfig({
+      context,
+      outPath: out,
+    });
+    process.exit(0);
+  },
+};
+
+export const read: CommandModuleWithWriteContext<{
+  strategy: string;
+}> = {
+  command: 'read',
+  describe: 'Reads strategy configuration',
+  builder: {
+    strategy: {
+      ...strategyCommandOption,
+      demandOption: true,
+      default: DEFAULT_STRATEGY_CONFIG_PATH,
+    },
+  },
+  handler: async ({ strategy: strategyUrl }) => {
+    logCommandHeader(`Hyperlane Strategy Read`);
+
+    const strategy = await readChainSubmissionStrategyConfig(strategyUrl);
+    const maskedConfig = maskSensitiveData(strategy);
+    log(indentYamlOrJson(yamlStringify(maskedConfig, null, 2), 4));
+
+    process.exit(0);
+  },
+};

typescript/cli/src/config/core.ts

@@ -39,7 +39,7 @@ export async function createCoreDeployConfig({
   logBlue('Creating a new core deployment config...');
 
   const owner = await detectAndConfirmOrPrompt(
-    async () => context.signer?.getAddress(),
+    async () => context.signerAddress,
     ENTER_DESIRED_VALUE_MSG,
     'owner address',
     SIGNER_PROMPT_LABEL,
@@ -64,7 +64,7 @@ export async function createCoreDeployConfig({
     });
     proxyAdmin = {
       owner: await detectAndConfirmOrPrompt(
-        async () => context.signer?.getAddress(),
+        async () => context.signerAddress,
         ENTER_DESIRED_VALUE_MSG,
         'ProxyAdmin owner address',
         SIGNER_PROMPT_LABEL,

typescript/cli/src/config/hooks.ts

@@ -243,10 +243,10 @@ async function getOwnerAndBeneficiary(
   advanced: boolean,
 ) {
   const unnormalizedOwner =
-    !advanced && context.signer
-      ? await context.signer.getAddress()
+    !advanced && context.signerAddress
+      ? context.signerAddress
       : await detectAndConfirmOrPrompt(
-          async () => context.signer?.getAddress(),
+          async () => context.signerAddress,
           `For ${module}, enter`,
           'owner address',
           'signer',

typescript/cli/src/config/ism.ts

@@ -163,10 +163,10 @@ export const createTrustedRelayerConfig = callWithConfigCreationLogs(
     advanced: boolean = false,
   ): Promise<TrustedRelayerIsmConfig> => {
     const relayer =
-      !advanced && context.signer
-        ? await context.signer.getAddress()
+      !advanced && context.signerAddress
+        ? context.signerAddress
         : await detectAndConfirmOrPrompt(
-            async () => context.signer?.getAddress(),
+            async () => context.signerAddress,
             'For trusted relayer ISM, enter',
             'relayer address',
             'signer',