fix decoding (#112)

Author: aelmanaa

ccip/cct/hardhat/tasks/getPoolConfig.ts

@@ -1,11 +1,13 @@
 import { task } from "hardhat/config";
 import {
   Chains,
-  networks,
   logger,
   getEVMNetworkConfig,
-  configData,
 } from "../config";
+import {
+  getChainInfoBySelector,
+  decodeChainAddress,
+} from "../utils/chainHandlers";
 
 // Define the interface for the task arguments
 interface GetPoolConfigArgs {
@@ -81,43 +83,40 @@ task("getPoolConfig", "Get pool configuration")
           poolContract.getCurrentInboundRateLimiterState(chainSelector), // Get inbound rate limits
         ]);
 
-        // Try to get a human-readable chain name from the network configuration
-        const chainName = Object.keys(networks).find(
-          (key) =>
-            configData[
-              key as keyof typeof configData
-            ]?.chainSelector?.toString() === chainSelector.toString()
-        );
+        // Get chain information using the utility function
+        const chainInfo = getChainInfoBySelector(chainSelector);
+        const chainDisplayName = chainInfo?.name || chainSelector.toString();
 
-        // Decode the remote pool addresses from their encoded form
+        // Decode the remote pool addresses using the utility function
         const remotePoolAddresses = remotePools.map((encodedPool) => {
+          if (!chainInfo) {
+            return "UNKNOWN_CHAIN";
+          }
           try {
-            return new hre.ethers.AbiCoder().decode(
-              ["address"],
-              encodedPool
-            )[0];
+            return decodeChainAddress(encodedPool, chainInfo.chainType, hre);
           } catch (error) {
-            return "DECODE_ERROR"; // Return error string if decoding fails
+            return "DECODE_ERROR";
           }
         });
 
-        // Decode the remote token address from its encoded form
+        // Decode the remote token address using the utility function
         let remoteTokenAddress;
-        try {
-          remoteTokenAddress = new hre.ethers.AbiCoder().decode(
-            ["address"],
-            remoteTokenAddressEncoded
-          )[0];
-        } catch (error) {
-          remoteTokenAddress = "DECODE_ERROR"; // Return error string if decoding fails
+        if (!chainInfo) {
+          remoteTokenAddress = "UNKNOWN_CHAIN";
+        } else {
+          try {
+            remoteTokenAddress = decodeChainAddress(
+              remoteTokenAddressEncoded,
+              chainInfo.chainType,
+              hre
+            );
+          } catch (error) {
+            remoteTokenAddress = "DECODE_ERROR";
+          }
         }
 
         // Display the chain-specific configuration
-        logger.info(
-          `\nConfiguration for Remote Chain: ${
-            chainName || chainSelector.toString()
-          }`
-        );
+        logger.info(`\nConfiguration for Remote Chain: ${chainDisplayName}`);
 
         // Display all remote pool addresses for this chain
         logger.info(`  Remote Pool Addresses:`);

ccip/cct/hardhat/utils/chainHandlers.ts

@@ -1,6 +1,7 @@
 import { CHAIN_TYPE } from "../config/types";
 import bs58 from "bs58";
 import type { HardhatRuntimeEnvironment } from "hardhat/types";
+import { configData } from "../config";
 
 /**
  * Error thrown when an invalid address is provided for a specific chain type
@@ -228,3 +229,98 @@ export function convertChainAddressToHex(
 export function isValidChainType(chainType: string): chainType is CHAIN_TYPE {
   return chainType === "evm" || chainType === "svm";
 }
+
+/**
+ * Interface for chain configuration lookup result
+ */
+export interface ChainInfo {
+  name: string;
+  chainType: CHAIN_TYPE;
+  chainSelector: string;
+  config: any;
+}
+
+/**
+ * Looks up chain information by chain selector
+ * @param chainSelector - The chain selector to look up
+ * @returns Chain information or undefined if not found
+ */
+export function getChainInfoBySelector(
+  chainSelector: string | bigint
+): ChainInfo | undefined {
+  const selectorString = chainSelector.toString();
+
+  const chainName = Object.keys(configData).find(
+    (key) =>
+      configData[key as keyof typeof configData]?.chainSelector?.toString() ===
+      selectorString
+  );
+
+  if (!chainName) {
+    return undefined;
+  }
+
+  const config = configData[chainName as keyof typeof configData];
+  const chainType = config.chainType as CHAIN_TYPE;
+
+  return {
+    name: chainName,
+    chainType,
+    chainSelector: selectorString,
+    config,
+  };
+}
+
+/**
+ * Decodes an encoded address based on the chain type
+ * @param encodedAddress - The encoded address data
+ * @param chainType - The chain type (evm or svm)
+ * @param hre - Hardhat runtime environment (optional, required for EVM)
+ * @returns The decoded address string
+ * @throws Error if decoding fails
+ */
+export function decodeChainAddress(
+  encodedAddress: string,
+  chainType: CHAIN_TYPE,
+  hre?: HardhatRuntimeEnvironment
+): string {
+  if (chainType === "svm") {
+    // For Solana, the encoded address is a hex string (32 bytes)
+    const hexString = encodedAddress.startsWith("0x")
+      ? encodedAddress.slice(2)
+      : encodedAddress;
+    const bytes = Buffer.from(hexString, "hex");
+    return bs58.encode(bytes);
+  } else if (chainType === "evm") {
+    if (!hre) {
+      throw new Error("HardhatRuntimeEnvironment is required for EVM address decoding");
+    }
+    // For EVM chains, use AbiCoder
+    return new hre.ethers.AbiCoder().decode(["address"], encodedAddress)[0];
+  } else {
+    throw new UnsupportedChainTypeError(chainType);
+  }
+}
+
+/**
+ * Decodes an address by first looking up the chain type from the selector
+ * @param encodedAddress - The encoded address data
+ * @param chainSelector - The chain selector
+ * @param hre - Hardhat runtime environment
+ * @returns The decoded address string or "UNKNOWN_CHAIN" if chain not found
+ */
+export function decodeAddressByChainSelector(
+  encodedAddress: string,
+  chainSelector: string | bigint,
+  hre: HardhatRuntimeEnvironment
+): string {
+  try {
+    const chainInfo = getChainInfoBySelector(chainSelector);
+    if (!chainInfo) {
+      return "UNKNOWN_CHAIN";
+    }
+    return decodeChainAddress(encodedAddress, chainInfo.chainType, hre);
+  } catch (error) {
+    return "DECODE_ERROR";
+  }
+}