add option to execute cosmos message with options

x/evm/contracts/counter/Counter.sol

@@ -9,6 +9,8 @@ contract Counter is IIBCAsyncCallback {
     uint256 public count;
 
     event increased(uint256 oldCount, uint256 newCount);
+    event callback_received(uint64 callback_id, bool success);
+    event recursive_called(uint64 n);
 
     constructor() payable {}
 
@@ -37,22 +39,36 @@ contract Counter is IIBCAsyncCallback {
         return COSMOS_CONTRACT.query_cosmos(path, req);
     }
 
-    function execute_cosmos(
-        string memory exec_msg,
-        bool call_revert
-    ) external {
+    function execute_cosmos(string memory exec_msg, bool call_revert) external {
         COSMOS_CONTRACT.execute_cosmos(exec_msg);
 
         if (call_revert) {
             revert("revert");
         }
     }
 
+    function execute_cosmos_with_options(
+        string memory exec_msg,
+        bool allow_failure,
+        uint64 callback_id
+    ) external {
+        COSMOS_CONTRACT.execute_cosmos_with_options(
+            exec_msg,
+            ICosmos.Options(allow_failure, callback_id)
+        );
+    }
+
+    function callback(uint64 callback_id, bool success) external {
+        emit callback_received(callback_id, success);
+    }
+
     function get_blockhash(uint64 n) external view returns (bytes32) {
         return blockhash(n);
     }
 
     function recursive(uint64 n) public {
+        emit recursive_called(n);
+
         if (n == 0) {
             return;
         }

x/evm/contracts/i_cosmos/ICosmos.sol

@@ -9,10 +9,14 @@ ICosmos constant COSMOS_CONTRACT = ICosmos(COSMOS_ADDRESS);
 
 interface ICosmos {
     // check if an address is blocked in bank module
-    function is_blocked_address(address account) external view returns (bool blocked);
+    function is_blocked_address(
+        address account
+    ) external view returns (bool blocked);
 
     // check if an address is a module account
-    function is_module_address(address account) external view returns (bool module);
+    function is_module_address(
+        address account
+    ) external view returns (bool module);
 
     // convert an EVM address to a Cosmos address
     function to_cosmos_address(
@@ -34,10 +38,10 @@ interface ICosmos {
         string memory denom
     ) external returns (address erc20_address);
 
-    // record a cosmos message to be executed
-    // after the current message execution.
+    // record a cosmos message to be executed after the current message execution.
+    // - if execution fails, whole transaction will be reverted.
     //
-    // msg should be in json string format like:
+    // `msg` format (json string):
     // {
     //    "@type": "/cosmos.bank.v1beta1.MsgSend",
     //    "from_address": "init13vhzmdmzsqlxkdzvygue9zjtpzedz7j87c62q4",
@@ -52,6 +56,36 @@ interface ICosmos {
     //
     function execute_cosmos(string memory msg) external returns (bool dummy);
 
+    // @args
+    // - `allow_failure`: if `true`, the transaction will not be reverted even if the execution fails.
+    // - `callback_id`: the callback id to be called after the execution. `0` means no callback.
+    struct Options {
+        bool allow_failure;
+        uint64 callback_id;
+    }
+
+    // record a cosmos message to be executed after the current message execution.
+    //
+    // `msg` format (json string):
+    // {
+    //    "@type": "/cosmos.bank.v1beta1.MsgSend",
+    //    "from_address": "init13vhzmdmzsqlxkdzvygue9zjtpzedz7j87c62q4",
+    //    "to_address": "init1enjh88u7c9s08fgdu28wj6umz94cetjy0hpcxf",
+    //    "amount": [
+    //        {
+    //            "denom": "stake",
+    //            "amount": "100"
+    //        }
+    //    ]
+    // }
+    //
+    // `callback` function signature in the caller contract (see ICosmosCallback.sol):
+    // - function callback(uint64 callback_id, bool success) external;
+    function execute_cosmos_with_options(
+        string memory msg,
+        Options memory options
+    ) external returns (bool dummy);
+
     // query a whitelisted cosmos querys.
     //
     // example)