powerdlz23 1.1.5 → 1.1.6

package/polymer/polymer-template/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "ibc-app-solidity-template",
+  "version": "1.0.0",
+  "description": "Template project to start building IBC enabled Solidity contracts, with Hardhat and Foundry support",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-ibc/ibc-app-solidity-template.git"
+  },
+  "keywords": [
+    "IBC",
+    "Solidity"
+  ],
+  "author": "Polymer Labs",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/open-ibc/ibc-app-solidity-template/issues"
+  },
+  "homepage": "https://github.com/open-ibc/ibc-app-solidity-template#readme",
+  "devDependencies": {
+    "@nomicfoundation/hardhat-foundry": "^1.1.1",
+    "@nomicfoundation/hardhat-toolbox": "^4.0.0",
+    "hardhat": "^2.19.5"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^4.7.6",
+    "axios": "^1.6.7",
+    "dotenv": "^16.4.1",
+    "hardhat-verify": "^1.0.0"
+  }
+}

package/polymer/polymer-template/remappings.txt

@@ -0,0 +1,5 @@
+@open-ibc/vibc-core-smart-contracts/=lib/vibc-core-smart-contracts/
+@lazyledger/protobuf3-solidity-lib/=lib/protobuf3-solidity-lib/
+ds-test/=lib/forge-std/lib/ds-test/src/
+forge-std/=lib/forge-std/src/
+

package/polymer/polymer-template/scripts/deploy.js

@@ -0,0 +1,51 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require("hardhat");
+const {getConfigPath} = require('./private/_helpers.js');
+const { getDispatcherAddress, getUcHandlerAddress } = require('./private/_vibc-helpers.js');
+
+async function main() {
+  const config = require(getConfigPath());
+  const argsObject = require('../contracts/arguments.js');
+  const networkName = hre.network.name;
+
+  // The config should have a deploy object with the network name as the key and contract type as the value
+  const contractType = config["deploy"][`${networkName}`];
+  const args = argsObject[`${contractType}`];
+  if (!args) {
+     console.warn(`No arguments found for contract type: ${contractType}`);
+  }
+
+  // TODO: update to switch statement when supporting more networks
+  let constructorArgs;
+  if (config.isUniversal) {
+    const ucHandlerAddr = getUcHandlerAddress(networkName);
+    constructorArgs = [ucHandlerAddr, ...(args ?? [])];
+  } else if (!config.isUniversal) {
+    const dispatcherAddr = getDispatcherAddress(networkName);
+    constructorArgs = [dispatcherAddr, ...(args ?? [])];
+  }
+  
+  // Deploy the contract
+  // NOTE: when adding additional args to the constructor, add them to the array as well
+  const myContract = await hre.ethers.deployContract(contractType, constructorArgs);
+
+  await myContract.waitForDeployment();
+
+  // NOTE: Do not change the output string, its output is formatted to be used in the deploy-config.js script
+  // to update the config.json file
+  console.log(
+    `Contract ${contractType} deployed to ${myContract.target} on network ${networkName}`
+  );
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/polymer/polymer-template/scripts/private/_create-channel-config.js

@@ -0,0 +1,62 @@
+const { exec } = require("child_process");
+const { getConfigPath, updateConfigCreateChannel, getWhitelistedNetworks } = require('./_helpers.js');
+const { setupIbcChannelEventListener } = require('./_events.js');
+
+// Function to run the deploy script and capture output
+function createChannelAndCapture() {
+  const config = require(getConfigPath());
+  const srcChain = config.createChannel.srcChain;
+  
+  // Check if the source chain from user input is whitelisted
+  const allowedNetworks = getWhitelistedNetworks();
+  if (!allowedNetworks.includes(srcChain)) {
+    console.error('❌ Invalid network name');
+    return;
+  }
+  exec(`npx hardhat run scripts/private/_create-channel.js --network ${srcChain}`, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`exec error: ${error}`);
+      return;
+    }
+
+    // Process stdout to find the contract address and network
+    const output = stdout.trim();
+    const match = output.match(/Channel created: (\S+) with portID (\S+) on network (\S+), Counterparty: (\S+) on network (\S+)/);
+
+    if (match) {
+      const channel = match[1];
+      const portId = match[2];
+      const network = match[3];
+      const cpChannel = match[4];
+      const cpNetwork = match[5];
+
+      console.log(`
+          🎊   Created Channel   🎊
+          -----------------------------------------
+          🛣️  Channel ID: ${channel}
+          🔗 Port ID: ${portId}
+          🌍 Network: ${network}
+          -----------------------------------------
+          🛣️  Counterparty Channel ID: ${cpChannel}
+          🪐 Counterparty Network: ${cpNetwork}
+          -----------------------------------------\n`
+        );
+
+      // Update the config.json file
+      updateConfigCreateChannel(network, channel, cpNetwork, cpChannel);
+      console.log(`🆗 Updated config.json with ${channel} on network ${network} and ${cpChannel} on network ${cpNetwork}`);
+    } else {
+      console.error("❌ Could not find required parameters in output");
+    }
+  });
+}
+
+async function main() {
+  await setupIbcChannelEventListener();
+  createChannelAndCapture();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/polymer/polymer-template/scripts/private/_create-channel.js

@@ -0,0 +1,96 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
+// will compile your contracts, add the Hardhat Runtime Environment's members to the
+// global scope, and execute the script.
+const hre = require('hardhat');
+const { getConfigPath, addressToPortId } = require('./_helpers');
+const { getIbcApp } = require('./_vibc-helpers.js');
+const ibcConfig = require('../../ibc.json');
+
+function createDummyProof() {
+  return  {
+      proof: [
+          {
+              path: [
+                  {
+                      prefix: hre.ethers.toUtf8Bytes("prefixExample1"),
+                      suffix: hre.ethers.toUtf8Bytes("suffixExample1"),
+                  },
+                  // Add more OpIcs23ProofPath objects as needed
+              ],
+              key: hre.ethers.toUtf8Bytes("keyExample"),
+              value: hre.ethers.toUtf8Bytes("valueExample"),
+              prefix: hre.ethers.toUtf8Bytes("prefixExample")
+          },
+          // Add more OpIcs23Proof objects as needed
+      ],
+      height: 123456, // example block height
+  };
+}
+
+async function main() {
+  const config = require(getConfigPath());
+  const chanConfig = config.createChannel;
+  const networkName = hre.network.name;
+  
+  // Get the contract type from the config and get the contract
+  const ibcApp = await getIbcApp(networkName);
+  const connectedChannelsBefore = await ibcApp.getConnectedChannels();
+
+  // Prepare the arguments to create the channel
+  const connHop1 = ibcConfig[chanConfig.srcChain][`${config.proofsEnabled ? 'op-client' : 'sim-client'}`].canonConnFrom;
+  const connHop2 = ibcConfig[chanConfig.dstChain][`${config.proofsEnabled ? 'op-client' : 'sim-client'}`].canonConnTo;
+  const srcPortId = addressToPortId(`polyibc.${chanConfig.srcChain}`, chanConfig.srcAddr);
+  const dstPortId = addressToPortId(`polyibc.${chanConfig.dstChain}`, chanConfig.dstAddr);
+
+  const local = {
+    portId: srcPortId,
+    channelId: hre.ethers.encodeBytes32String(''),
+    version: chanConfig.version,
+  };
+
+  const cp = {
+    portId: dstPortId,
+    channelId: hre.ethers.encodeBytes32String(''),
+    version: '',
+  };
+
+  // Create the channel
+  // Note: The proofHeight and proof are dummy values and will be dropped in the future
+  await ibcApp.createChannel(
+    local,
+    chanConfig.ordering,
+    chanConfig.fees,
+    [ connHop1, connHop2 ],
+    cp,
+    createDummyProof()
+  );
+
+  if (!config.proofsEnabled) {
+    // Wait for the channel handshake to complete
+    await new Promise((r) => setTimeout(r, 90000));
+
+    // Get the connected channels and print the new channel along with its counterparty
+    const connectedChannelsAfter = await ibcApp.getConnectedChannels();
+
+    if (connectedChannelsAfter!== undefined && connectedChannelsAfter.length > connectedChannelsBefore.length) {
+
+      const newChannelBytes = connectedChannelsAfter[connectedChannelsAfter.length - 1].channelId;
+      const newChannel = hre.ethers.decodeBytes32String(newChannelBytes);
+
+      const cpChannelBytes = connectedChannelsAfter[connectedChannelsAfter.length - 1].cpChannelId;
+      const cpChannel = hre.ethers.decodeBytes32String(cpChannelBytes);
+    
+      console.log(`✅ Channel created: ${newChannel} with portID ${srcPortId} on network ${networkName}, Counterparty: ${cpChannel} on network ${chanConfig.dstChain}`);
+    }
+  }
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/polymer/polymer-template/scripts/private/_deploy-config.js

@@ -0,0 +1,62 @@
+const { exec } = require("child_process");
+const { updateConfigDeploy, getWhitelistedNetworks } = require('./_helpers');
+
+// Run script with source and destination networks as arguments
+// Example: 
+// $ node deploy-config.js optimism base
+const source = process.argv[2];
+const destination = process.argv[3];
+
+if (!source || !destination) {
+  console.error('Usage: node deploy-config.js <source_network> <destination_network>');
+  process.exit(1);
+}
+
+// Function to run the deploy script and capture output
+function deployAndCapture(network, isSource) {
+  const allowedNetworks = getWhitelistedNetworks();
+  if (!allowedNetworks.includes(network)) {
+    console.error('Invalid network. Please provide a valid network as an argument.');
+    return;
+  }
+  exec(`npx hardhat run scripts/deploy.js --network ${network}`, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`exec error: ${error}`);
+      return;
+    } else {
+      console.log(stdout);
+    }
+
+    // Process stdout to find the contract address and network
+    const output = stdout.trim();
+    const match = output.match(/Contract (\S+) deployed to (\S+) on network (\S+)/);
+
+    if (match) {
+      const contractType = match[1];
+      const address = match[2];
+      const network = match[3];
+
+      console.log(`
+          ✅   Deployment Successful   ✅
+          -------------------------------
+          📄 Contract Type: ${contractType}
+          📍 Address: ${address}
+          🌍 Network: ${network}
+          -------------------------------\n
+      `);
+
+      // Update the config.json file
+      updateConfigDeploy(network, address, isSource);
+      console.log(`🆗 Updated ${process.env.CONFIG_PATH || 'config.json'} with address ${address} on network ${network}`);
+    } else {
+      console.error("❌ Could not find contract address and network in output");
+    }
+  });
+}
+
+function main() {
+  deployAndCapture(source, true);
+  deployAndCapture(destination, false);
+}
+
+main();

package/polymer/polymer-template/scripts/private/_events.js

@@ -0,0 +1,241 @@
+const hre = require("hardhat");
+const { areAddressesEqual, getConfigPath } = require("./_helpers.js");
+const { getDispatcher, getUcHandlerAddress } = require("./_vibc-helpers.js");
+
+const explorerOpUrl = "https://optimism-sepolia.blockscout.com/";
+const explorerBaseUrl = "https://base-sepolia.blockscout.com/";
+
+function filterChannelEvents(portAddress) {
+    const config = require(getConfigPath());
+    return areAddressesEqual(portAddress, config.createChannel["srcAddr"]) || areAddressesEqual(portAddress, config.createChannel["dstAddr"]);
+}
+
+function listenForIbcChannelEvents(network, source, dispatcher) {
+    const explorerUrl = network === "optimism" ? explorerOpUrl : explorerBaseUrl;
+    console.log(`👂 Listening for IBC channel events on ${network}...`);
+    dispatcher.on(
+        "OpenIbcChannel",
+        (portAddress, version, ordering, feeEnabled, connectionHops, counterparytPortId, counterpartyChannelId, event) => {
+            const txHash = event.log.transactionHash;
+            const counterpartyChannelIdString = hre.ethers.decodeBytes32String(counterpartyChannelId);
+            const url = `${explorerUrl}tx/${txHash}`;
+
+            if (filterChannelEvents(portAddress)) {
+                console.log(`
+          -------------------------------------------`);
+                if (source) {
+                    console.log(`
+          🙋‍♀️   CHANNEL OPEN INIT !!!   🙋‍♀️`);
+                } else {
+                    console.log(`
+          🙋‍♂️   CHANNEL OPEN TRY !!!   🙋‍♂️`);
+                }
+
+                console.log(`
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Port Address: ${portAddress}
+          🔗 Counterparty Port ID: ${counterparytPortId}
+          🛣️  Counterparty Channel ID: ${counterpartyChannelIdString}
+          🦘 Connection Hops: ${connectionHops}
+          🔀 Ordering: ${ordering}
+          💰 Fee Enabled: ${feeEnabled}
+          #️⃣  Version: ${version}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+
+                if (source) {
+                    console.log(` ⏱️  Waiting for channel open try...`);
+                } else {
+                    console.log(` ⏱️  Waiting for channel open ack...`);
+                }
+            }
+        }
+    );
+
+    dispatcher.on("ConnectIbcChannel", (portAddress, channelId, event) => {
+        const txHash = event.log.transactionHash;
+        const channelIdString = hre.ethers.decodeBytes32String(channelId);
+        const url = `${explorerUrl}tx/${txHash}`;
+        if (filterChannelEvents(portAddress)) {
+            console.log(`
+          -------------------------------------------`);
+            if (source) {
+                console.log(`
+          👩‍❤️‍💋‍👨   CHANNEL OPEN ACK !!!   👩‍❤️‍💋‍👨`);
+            } else {
+                console.log(`
+          🤵‍♂️💍👰‍♀️   CHANNEL OPEN CONFIRM !!!   👰‍♀️💍🤵‍♂️`);
+            }
+            console.log(`
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Port Address: ${portAddress}
+          🛣️  Channel ID: ${channelIdString}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+            if (source) {
+                console.log(` ⏱️  Waiting for channel open confirm...`);
+            } else {
+                console.log(` ⏱️  Waiting for channel creation overview...`);
+            }
+        }
+        dispatcher.removeAllListeners();
+    });
+
+    dispatcher.on("CloseIbcChannel", (portAddress, channelId, event) => {
+        const txHash = event.log.transactionHash;
+        const channelIdString = hre.ethers.decodeBytes32String(channelId);
+        const url = `${explorerUrl}tx/${txHash}`;
+        if (filterChannelEvents(portAddress)) {
+            console.log(`
+          -------------------------------------------
+          🔗 🔒   IBC CHANNEL CLOSED !!!   🔗 🔒
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Port Address: ${portAddress}
+          🛣️  Channel ID: ${channelIdString}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+        }
+        dispatcher.removeAllListeners();
+    });
+}
+
+function filterPacketEvents(portAddress, network) {
+    const config = require(getConfigPath());
+    const sendPacketConfig = config.sendPacket;
+    const ucHandlerAddr = getUcHandlerAddress(network);
+
+    return areAddressesEqual(portAddress, sendPacketConfig[`${network}`].portAddr) || areAddressesEqual(portAddress, ucHandlerAddr);
+}
+
+function listenForIbcPacketEvents(network, dispatcher) {
+    const explorerUrl = network === "optimism" ? explorerOpUrl : explorerBaseUrl;
+    console.log(`👂 Listening for IBC packet events on ${network}...`);
+
+    dispatcher.on("SendPacket", (sourcePortAddress, sourceChannelId, packet, sequence, timeoutTimestamp, event) => {
+        const txHash = event.log.transactionHash;
+        const sourceChannelIdString = hre.ethers.decodeBytes32String(sourceChannelId);
+        const url = `${explorerUrl}tx/${txHash}`;
+
+        if (filterPacketEvents(sourcePortAddress, network)) {
+            console.log(` 
+          -------------------------------------------
+          📦 📮   PACKET HAS BEEN SENT !!!   📦 📮
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Source Port Address: ${sourcePortAddress}
+          🛣️  Source Channel ID: ${sourceChannelIdString}
+          📈 Sequence: ${sequence}
+          ⏳ Timeout Timestamp: ${timeoutTimestamp}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+            console.log(` ⏱️  Waiting for packet receipt...`);
+        }
+    });
+
+    dispatcher.on("RecvPacket", (destPortAddress, destChannelId, sequence, event) => {
+        const txHash = event.log.transactionHash;
+        const destChannelIdString = hre.ethers.decodeBytes32String(destChannelId);
+        const url = `${explorerUrl}tx/${txHash}`;
+
+        if (filterPacketEvents(destPortAddress,network)) {
+            console.log(`
+          -------------------------------------------
+          📦 📬   PACKET IS RECEIVED !!!   📦 📬
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Destination Port Address: ${destPortAddress}
+          🛣️  Destination Channel ID: ${destChannelIdString}
+          📈 Sequence: ${sequence}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+            console.log(` ⏱️  Waiting for write acknowledgement...`);
+        }
+    });
+
+    dispatcher.on("WriteAckPacket", (writerPortAddress, writerChannelId, sequence, ackPacket, event) => {
+        const txHash = event.log.transactionHash;
+        const writerChannelIdString = hre.ethers.decodeBytes32String(writerChannelId);
+        const url = `${explorerUrl}tx/${txHash}`;
+        if (filterPacketEvents(writerPortAddress, network)) {
+            console.log(` 
+          -------------------------------------------
+          📦 📝   ACKNOWLEDGEMENT WRITTEN !!!   📦 📝
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Destination Port Address: ${writerPortAddress}
+          🛣️  Channel ID: ${writerChannelIdString}
+          📈 Sequence: ${sequence}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+            console.log(` ⏱️  Waiting for acknowledgement...`);
+        }
+        dispatcher.removeAllListeners();
+    });
+
+    dispatcher.on("Acknowledgement", (sourcePortAddress, sourceChannelId, sequence, event) => {
+        const txHash = event.log.transactionHash;
+        const sourceChannelIdString = hre.ethers.decodeBytes32String(sourceChannelId);
+        const url = `${explorerUrl}tx/${txHash}`;
+        if (filterPacketEvents(sourcePortAddress, network)) {
+            console.log(`   
+          -------------------------------------------
+          📦 🏁   PACKET IS ACKNOWLEDGED !!!   📦 🏁
+          -------------------------------------------
+          🔔 Event name: ${event.log.fragment.name}
+          ⛓️  Network: ${network}
+          🔗 Source Port Address: ${sourcePortAddress}
+          🛣️  Source Channel ID: ${sourceChannelIdString}
+          📈 Sequence: ${sequence}
+          -------------------------------------------
+          🧾 TxHash: ${txHash}
+          🔍 Explorer URL: ${url}
+          -------------------------------------------\n`);
+        }
+        dispatcher.removeAllListeners();
+    });
+}
+
+async function setupIbcPacketEventListener() {
+    console.log("🔊 Setting up IBC packet event listener...")
+    // Get the dispatchers for both source and destination to listen for IBC packet events
+    const opDispatcher = await getDispatcher("optimism");
+    const baseDispatcher = await getDispatcher("base");
+    listenForIbcPacketEvents("optimism", opDispatcher);
+    listenForIbcPacketEvents("base", baseDispatcher);
+}
+
+async function setupIbcChannelEventListener() {
+    console.log("🔊 Setting up IBC channel event listener...")
+    const config = require(getConfigPath());
+    const opIsSource = config.createChannel.srcChain === "optimism";
+    const baseIsSource = config.createChannel.srcChain === "base";
+
+    // Get the dispatchers for both source and destination to listen for IBC packet events
+    const opDispatcher = await getDispatcher("optimism");
+    const baseDispatcher = await getDispatcher("base");
+    listenForIbcChannelEvents("optimism", opIsSource , opDispatcher);
+    listenForIbcChannelEvents("base", baseIsSource, baseDispatcher);
+}
+
+module.exports = { listenForIbcChannelEvents, listenForIbcPacketEvents, setupIbcPacketEventListener, setupIbcChannelEventListener };

package/polymer/polymer-template/scripts/private/_helpers.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const axios = require('axios');
+const hre = require('hardhat');
+const ibcConfig = require("../../ibc.json");
+
+// Function to get the path to the configuration file
+function getConfigPath() {
+  const path = require('path');
+  const configRelativePath = process.env.CONFIG_PATH ? process.env.CONFIG_PATH : 'config.json';
+  // console.log(`📔 Using config file at ${configRelativePath}`);
+  const configPath = path.join(__dirname, '../..' , configRelativePath);
+  return configPath;
+}
+
+// Function to update config.json
+function updateConfigDeploy(network, address, isSource) {
+  try {
+    const configPath = getConfigPath();
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    // Update the config object
+    if (!config.isUniversal) {
+      if (isSource) {
+        config["createChannel"]["srcChain"] = network;
+        config["createChannel"]["srcAddr"] = address;
+      } else {
+        config["createChannel"]["dstChain"] = network;
+        config["createChannel"]["dstAddr"] = address;
+      }
+  
+      config["sendPacket"][`${network}`]["portAddr"] = address;    
+    } else if (config.isUniversal){
+      // When using the universal channel, we can skip channel creation and instead update the sendUniversalPacket field in the config
+      const client = config.proofsEnabled ? 'op-client' : 'sim-client';
+      config["sendUniversalPacket"][`${network}`]["portAddr"] = address;
+      config["sendUniversalPacket"][`${network}`]["channelId"] = ibcConfig[`${network}`][`${client}`]["universalChannel"];
+    }
+  
+    // Write the updated config back to the file
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch (error) {
+    console.error('❌ Error updating config:', error);
+  }
+}
+
+// Function to update config.json
+function updateConfigCreateChannel(network, channel, cpNetwork, cpChannel) {
+  try {
+    const configPath = getConfigPath();
+    const upConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  
+    // Update the config object
+    upConfig["sendPacket"][`${network}`]["channelId"] = channel;
+    upConfig["sendPacket"][`${cpNetwork}`]["channelId"] = cpChannel;
+  
+    // Write the updated config back to the file
+    fs.writeFileSync(configPath, JSON.stringify(upConfig, null, 2));
+  } catch (error) {
+    console.error('❌ Error updating config:', error);
+  }
+}
+
+async function fetchABI(explorerUrl, contractAddress) {
+  try {
+    const response = await axios.get(`${explorerUrl}api/v2/smart-contracts/${contractAddress}`);
+    if (response.status === 200) {
+      const abi = response.data.abi;
+      return abi;
+    } else {
+      console.error(`❌ Failed to fetch ABI, status code: ${response.status}`);
+      return null;
+    }
+  } catch (error) {
+    console.error('❌ Error fetching ABI:', error);
+    return null;
+  }
+}
+
+function areAddressesEqual(address1, address2) {
+  // Validate input addresses
+  if (!hre.ethers.isAddress(address1) || !hre.ethers.isAddress(address2)) {
+    throw new Error('❌ One or both addresses are not valid Ethereum addresses');
+  }
+  // Normalize addresses to checksummed format
+
+  const checksumAddress1 = hre.ethers.getAddress(address1);
+  const checksumAddress2 = hre.ethers.getAddress(address2);
+
+  // Compare addresses
+  const areEqual = checksumAddress1 === checksumAddress2;
+  return areEqual;
+}
+
+// Helper function to convert an address to a port ID
+function addressToPortId(portPrefix, address) {
+  const config = require(getConfigPath());
+  const simAddOn = config.proofsEnabled ? '-proofs-1' :'-sim';
+  const suffix = address.slice(2);
+  return `${portPrefix}${simAddOn}.${suffix}`;
+}
+
+function getWhitelistedNetworks() {
+  return Object.keys(ibcConfig);
+}
+
+module.exports = { 
+  getConfigPath,
+  updateConfigDeploy,
+  updateConfigCreateChannel,
+  fetchABI,
+  areAddressesEqual,
+  addressToPortId,
+  getWhitelistedNetworks
+};