feat: add authz and feegrant support

README.md

@@ -352,6 +352,19 @@ The decoder returns a structured object with the following format:
 - `/initia.mstaking.v1.MsgUndelegate`
 - `/initia.mstaking.v1.MsgBeginRedelegate`
 
+#### Authz Messages
+
+- `/cosmos.authz.v1beta1.MsgExec` - Execute authorized messages on behalf of another account
+- `/cosmos.authz.v1beta1.MsgGrant` - Grant authorization to another account
+- `/cosmos.authz.v1beta1.MsgRevoke` - Revoke a previously granted authorization
+
+#### Feegrant Messages
+
+- `/cosmos.feegrant.v1beta1.MsgGrantAllowance` - Grant a fee allowance to another account
+- `/cosmos.feegrant.v1beta1.MsgRevokeAllowance` - Revoke an existing fee allowance
+
+**Note:** MsgExec recursively decodes the inner messages it contains. All currently supported message types can be wrapped within MsgExec and will be properly decoded.
+
 ### Move VM Messages
 
 - `/initia.move.v1.MsgExecute`

src/decoder-registry.ts

@@ -1,7 +1,16 @@
 import * as Decoders from "./decoders";
 import { MessageDecoder } from "./interfaces";
 
+const cosmosAuthDecoders: MessageDecoder[] = [
+  Decoders.authzExecDecoder,
+  Decoders.authzGrantDecoder,
+  Decoders.authzRevokeDecoder,
+  Decoders.feegrantGrantAllowanceDecoder,
+  Decoders.feegrantRevokeAllowanceDecoder
+];
+
 export const cosmosEvmMessageDecoders: MessageDecoder[] = [
+  ...cosmosAuthDecoders,
   Decoders.sendDecoder,
   Decoders.finalizeTokenDepositDecoder,
   Decoders.initiateTokenWithdrawalDecoder,
@@ -12,6 +21,7 @@ export const cosmosEvmMessageDecoders: MessageDecoder[] = [
 ];
 
 export const cosmosWasmMessageDecoders: MessageDecoder[] = [
+  ...cosmosAuthDecoders,
   Decoders.sendDecoder,
   Decoders.initiateTokenWithdrawalDecoder,
   Decoders.finalizeTokenDepositDecoder,
@@ -28,6 +38,7 @@ export const cosmosWasmMessageDecoders: MessageDecoder[] = [
 ];
 
 export const cosmosMoveMessageDecoders: MessageDecoder[] = [
+  ...cosmosAuthDecoders,
   Decoders.claimMinitswapDecoder,
   Decoders.delegateDecoder,
   Decoders.delegateLockedDecoder,

src/decoder.ts

@@ -151,7 +151,6 @@ export class TxDecoder {
   ): Promise<DecodedEthereumTx> {
     const ethereumPayload = validateAndPrepareEthereumPayload(payload);
 
-    // PRE-CHECK: Is this a mirrored Cosmos transaction?
     const cosmosTxHash = extractCosmosTxHashFromEvm(ethereumPayload);
     if (cosmosTxHash) {
       try {
@@ -167,7 +166,6 @@ export class TxDecoder {
       }
     }
 
-    // Regular Ethereum transaction flow
     const decoder = this._findEthereumDecoder(ethereumPayload);
 
     const balanceChanges = await calculateBalanceChangesFromEthereumLogs(
@@ -221,28 +219,13 @@ export class TxDecoder {
   ): ReturnType<MessageDecoder["decode"]> {
     const notSupportedMessage = createNotSupportedMessage(message["@type"]);
 
-    // For failed transactions (code !== 0), logs array is empty
-    // Create a synthetic log from txResponse events to allow decoders to process the message
     const effectiveLog: Log = log || {
       events: txResponse.events,
       log: txResponse.raw_log,
       msg_index: messageIndex
     };
 
-    let decoders;
-    switch (vm) {
-      case "evm":
-        decoders = cosmosEvmMessageDecoders;
-        break;
-      case "move":
-        decoders = cosmosMoveMessageDecoders;
-        break;
-      case "wasm":
-        decoders = cosmosWasmMessageDecoders;
-        break;
-      default:
-        throw new Error(`Unknown VM type: ${vm}`);
-    }
+    const decoders = this._getDecodersForVm(vm);
 
     try {
       const decoder = this._findDecoderForMessage(
@@ -258,32 +241,24 @@ export class TxDecoder {
         effectiveLog,
         this.apiClient,
         txResponse,
-        vm
+        vm,
+        this._getDecodersForVm.bind(this)
       );
     } catch (e) {
       console.error(e);
       return notSupportedMessage;
     }
   }
 
-  /**
-   * Decodes a mirrored Cosmos transaction by fetching and decoding the original Cosmos tx.
-   *
-   * Returns only the cosmos messages in the data field to avoid duplication.
-   * Metadata and totalBalanceChanges are at the root level only.
-   */
   private async _decodeMirroredCosmosTx(
     cosmosTxHash: string,
     ethereumPayload: EthereumRpcPayload
   ): Promise<DecodedEthereumTx> {
-    // Fetch the Cosmos transaction from REST API
     const cosmosTxResponse = await this.apiClient.getCosmosTx(cosmosTxHash);
 
-    // Decode it using the Cosmos transaction decoder
     const decodedCosmosEvmTx =
       await this.decodeCosmosEvmTransaction(cosmosTxResponse);
 
-    // Return in cosmos_mirror format
     return {
       decodedTransaction: {
         action: "cosmos_mirror",
@@ -293,7 +268,6 @@ export class TxDecoder {
           evmTxHash: ethereumPayload.tx.hash
         }
       },
-      // Metadata and balance changes from the decoded Cosmos transaction
       metadata: decodedCosmosEvmTx.metadata,
       totalBalanceChanges: decodedCosmosEvmTx.totalBalanceChanges
     };
@@ -312,6 +286,19 @@ export class TxDecoder {
     return ethereumDecoders.find((decoder) => decoder.check(payload));
   }
 
+  private _getDecodersForVm(vm: VmType): MessageDecoder[] {
+    switch (vm) {
+      case "evm":
+        return cosmosEvmMessageDecoders;
+      case "move":
+        return cosmosMoveMessageDecoders;
+      case "wasm":
+        return cosmosWasmMessageDecoders;
+      default:
+        throw new Error(`Unknown VM type: ${vm}`);
+    }
+  }
+
   private async _processMessages(
     txResponse: TxResponse,
     vm: VmType

src/decoders/cosmos/authz.ts

@@ -0,0 +1,144 @@
+import type { ApiClient } from "@/api";
+import type { DecodedMessage, MessageDecoder, VmType } from "@/interfaces";
+
+import { SUPPORTED_MESSAGE_TYPES } from "@/message-types";
+import {
+  Log,
+  Message,
+  TxResponse,
+  zMsgExec,
+  zMsgGrant,
+  zMsgRevoke
+} from "@/schema";
+import { createNotSupportedMessage } from "@/utils";
+
+export const authzExecDecoder: MessageDecoder = {
+  check: (message, _log) =>
+    message["@type"] === SUPPORTED_MESSAGE_TYPES.MsgExec,
+  decode: async (
+    message: Message,
+    log: Log,
+    apiClient: ApiClient,
+    txResponse: TxResponse,
+    vm: VmType,
+    getDecodersForVm?: (vm: VmType) => MessageDecoder[]
+  ) => {
+    const parsed = zMsgExec.safeParse(message);
+    if (!parsed.success) {
+      throw new Error("Invalid authz exec message");
+    }
+
+    const { grantee, msgs } = parsed.data;
+
+    if (!getDecodersForVm) {
+      const decodedMessage: DecodedMessage = {
+        action: "authz_exec",
+        data: {
+          grantee,
+          messages: msgs.map((msg) => createNotSupportedMessage(msg["@type"]))
+        },
+        isIbc: false,
+        isOp: false
+      };
+      return decodedMessage;
+    }
+
+    const decoders = getDecodersForVm(vm);
+
+    const decodedInnerMessages: DecodedMessage[] = [];
+    for (const innerMessage of msgs) {
+      const decoder = decoders.find((d) => d.check(innerMessage, log, vm));
+
+      if (decoder) {
+        const decoded = await decoder.decode(
+          innerMessage,
+          log,
+          apiClient,
+          txResponse,
+          vm,
+          getDecodersForVm
+        );
+        decodedInnerMessages.push(decoded);
+      } else {
+        decodedInnerMessages.push(
+          createNotSupportedMessage(innerMessage["@type"])
+        );
+      }
+    }
+
+    const decodedMessage: DecodedMessage = {
+      action: "authz_exec",
+      data: {
+        grantee,
+        messages: decodedInnerMessages
+      },
+      isIbc: false,
+      isOp: false
+    };
+
+    return decodedMessage;
+  }
+};
+
+export const authzGrantDecoder: MessageDecoder = {
+  check: (message, _log) =>
+    message["@type"] === SUPPORTED_MESSAGE_TYPES.MsgGrant,
+  decode: async (
+    message: Message,
+    _log: Log,
+    _apiClient: ApiClient,
+    _txResponse: TxResponse
+  ) => {
+    const parsed = zMsgGrant.safeParse(message);
+    if (!parsed.success) {
+      throw new Error("Invalid authz grant message");
+    }
+
+    const { grant, grantee, granter } = parsed.data;
+
+    const decodedMessage: DecodedMessage = {
+      action: "authz_grant",
+      data: {
+        authorization: grant.authorization,
+        expiration: grant.expiration,
+        grantee,
+        granter
+      },
+      isIbc: false,
+      isOp: false
+    };
+
+    return decodedMessage;
+  }
+};
+
+export const authzRevokeDecoder: MessageDecoder = {
+  check: (message, _log) =>
+    message["@type"] === SUPPORTED_MESSAGE_TYPES.MsgRevoke,
+  decode: async (
+    message: Message,
+    _log: Log,
+    _apiClient: ApiClient,
+    _txResponse: TxResponse
+  ) => {
+    const parsed = zMsgRevoke.safeParse(message);
+    if (!parsed.success) {
+      throw new Error("Invalid authz revoke message");
+    }
+
+    const { grantee, granter, msg_type_url } = parsed.data;
+
+    const decodedMessage: DecodedMessage = {
+      action: "authz_revoke",
+      data: {
+        grantee,
+        granter,
+        msg_type_url
+      },
+      isIbc: false,
+      isOp: false
+    };
+
+    return decodedMessage;
+  }
+};

src/decoders/cosmos/feegrant.ts

@@ -0,0 +1,72 @@
+import type { ApiClient } from "@/api";
+import type { DecodedMessage, MessageDecoder } from "@/interfaces";
+
+import { SUPPORTED_MESSAGE_TYPES } from "@/message-types";
+import {
+  Log,
+  Message,
+  TxResponse,
+  zMsgGrantAllowance,
+  zMsgRevokeAllowance
+} from "@/schema";
+
+export const feegrantGrantAllowanceDecoder: MessageDecoder = {
+  check: (message, _log) =>
+    message["@type"] === SUPPORTED_MESSAGE_TYPES.MsgGrantAllowance,
+  decode: async (
+    message: Message,
+    _log: Log,
+    _apiClient: ApiClient,
+    _txResponse: TxResponse
+  ) => {
+    const parsed = zMsgGrantAllowance.safeParse(message);
+    if (!parsed.success) {
+      throw new Error("Invalid feegrant grant allowance message");
+    }
+
+    const { allowance, grantee, granter } = parsed.data;
+
+    const decodedMessage: DecodedMessage = {
+      action: "feegrant_grant_allowance",
+      data: {
+        allowance,
+        grantee,
+        granter
+      },
+      isIbc: false,
+      isOp: false
+    };
+
+    return decodedMessage;
+  }
+};
+
+export const feegrantRevokeAllowanceDecoder: MessageDecoder = {
+  check: (message, _log) =>
+    message["@type"] === SUPPORTED_MESSAGE_TYPES.MsgRevokeAllowance,
+  decode: async (
+    message: Message,
+    _log: Log,
+    _apiClient: ApiClient,
+    _txResponse: TxResponse
+  ) => {
+    const parsed = zMsgRevokeAllowance.safeParse(message);
+    if (!parsed.success) {
+      throw new Error("Invalid feegrant revoke allowance message");
+    }
+
+    const { grantee, granter } = parsed.data;
+
+    const decodedMessage: DecodedMessage = {
+      action: "feegrant_revoke_allowance",
+      data: {
+        grantee,
+        granter
+      },
+      isIbc: false,
+      isOp: false
+    };
+
+    return decodedMessage;
+  }
+};

src/decoders/cosmos/index.ts

@@ -1,5 +1,7 @@
+export * from "./authz";
 export * from "./bank";
 export * from "./distribution";
+export * from "./feegrant";
 export * from "./move";
 export * from "./mstaking";
 export * from "./wasm";