powerdlz23 1.1.5 → 1.1.7

package/polymer/polymer-template/scripts/private/_sanity-check-custom.js

@@ -0,0 +1,69 @@
+// 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('./_helpers');
+const { areAddressesEqual } = require("./_helpers");
+const { getIbcApp } = require("./_vibc-helpers");
+
+async function main() {
+    const configPath = getConfigPath();
+    const config = require(configPath);
+    const accounts = await hre.ethers.getSigners();
+    const networkName = hre.network.name;
+
+    // Get the Dispatcher from your IBC enabled contract and compare it with the stored value in the .env file
+
+    // 1. Get the contract type from the config and get the contract
+    const ibcApp = await getIbcApp(networkName);
+
+    // 2. Query your contract for the Dispatcher address
+    let dispatcherAddr
+    try {
+        dispatcherAddr = await ibcApp.dispatcher();
+    } catch (error) { 
+        console.log(`❌ Error getting dispatcher address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
+        return;
+    }
+
+    // 3. Compare with the value expected in the .env config file
+    let sanityCheck = false;
+    let envDispatcherAddr;
+    try {
+        if (networkName === "optimism") {
+            envDispatcherAddr = config.proofsEnabled === true ? process.env.OP_DISPATCHER : process.env.OP_DISPATCHER_SIM;
+            sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
+        } else if (networkName === "base") {
+            envDispatcherAddr = config.proofsEnabled === true ? process.env.BASE_DISPATCHER : process.env.BASE_DISPATCHER_SIM;
+            sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
+        }
+    } catch (error) {
+        console.log(`❌ Error comparing dispatcher addresses in .env file and IBC app: ${error}`);
+        return;
+    }
+
+    // 4. Print the result of the sanity check 
+    // If true, it means all values in the contracts check out with those in the .env file and we can continue with the other scripts.
+    if (sanityCheck) {
+        console.log(`✅ Sanity check passed for network ${networkName}`);
+    } else {    
+        console.log(`
+⛔ Sanity check failed for network ${networkName}, 
+check if the values provided in the .env file for the Universal Channel Mw and the dispatcher are correct.
+--------------------------------------------------
+🔮 Expected dispatcher (in IBC contract): ${dispatcherAddr}...
+🗃️ Found dispatcher (in .env file): ${envDispatcherAddr}...
+--------------------------------------------------
+        `);
+    }
+}
+
+// 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/_sanity-check-universal.js

@@ -0,0 +1,120 @@
+// 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, areAddressesEqual } = require('./_helpers.js');
+const { getIbcApp, getUcHandler } = require("./_vibc-helpers.js");
+
+async function main() {
+    const config = require(getConfigPath());
+    const accounts = await hre.ethers.getSigners();
+    const networkName = hre.network.name;
+
+    // Get the Universal Channel Mw from your IBC enabled contract and comare it with the values in the .env file
+
+    // 1. Get the contract type from the config and get the contract
+    const ibcApp = await getIbcApp(networkName);
+
+    // 2. Query your app for the Universal Channel Mw address stored
+    let ucHandlerAddr;
+    try {
+        ucHandlerAddr = await ibcApp.mw();
+    } catch (error) {
+        console.log(`❌ Error getting Universal Channel Mw address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
+        return;
+    }
+
+    // 3. Compare with the value expected in the .env config file
+    let sanityCheck = false;
+    let envUcHandlerAddr;
+    try {
+        if (networkName === "optimism") {
+            envUcHandlerAddr = config.proofsEnabled === true ? process.env.OP_UC_MW : process.env.OP_UC_MW_SIM;
+            sanityCheck = areAddressesEqual(ucHandlerAddr, envUcHandlerAddr);
+        } else if (networkName === "base") {
+            envUcHandlerAddr = config.proofsEnabled === true ? process.env.BASE_UC_MW : process.env.BASE_UC_MW_SIM;
+            sanityCheck = areAddressesEqual(ucHandlerAddr, envUcHandlerAddr);
+        }
+    } catch (error) {
+        console.log(`❌ Error comparing Universal Channel Mw addresses in .env file and IBC app: ${error}`);
+        return;
+    }
+
+    // 4. If true, we continue to check the dispatcher stored in the Universal Channel Mw
+    let envDispatcherAddr;
+    let dispatcherAddr;
+    let ucHandler;
+    
+    if (sanityCheck) {
+        try {
+            ucHandler = await getUcHandler(networkName);
+            dispatcherAddr = await ucHandler.dispatcher();
+            if (networkName === "optimism") {
+                envDispatcherAddr = config.proofsEnabled === true ? process.env.OP_DISPATCHER : process.env.OP_DISPATCHER_SIM;
+                sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
+            } else if (networkName === "base") {
+                envDispatcherAddr = config.proofsEnabled === true ? process.env.BASE_DISPATCHER : process.env.BASE_DISPATCHER_SIM;
+                sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
+            } else {
+                sanityCheck = false;
+            }
+        } catch (error) {
+            console.log(`❌ Error getting dispatcher address from Universal Channel Mw or from config: ${error}`);
+            return;
+        }
+    } else {
+        console.log(`
+⛔ Sanity check failed for network ${networkName}, 
+check if the values provided in the .env file for the Universal Channel Mw and the dispatcher are correct.
+--------------------------------------------------
+🔮 Expected Universal Channel Handler (in IBC contract): ${ucHandlerAddr}...
+🗃️  Found Universal Channel Handler (in .env file): ${envUcHandlerAddr}...
+--------------------------------------------------
+        `);
+        return;
+    }
+
+    if (sanityCheck) {
+        const channelBytes = await ucHandler.connectedChannels(0);
+        const channelId = hre.ethers.decodeBytes32String(channelBytes);
+        const envChannelId = config["sendUniversalPacket"][networkName]["channelId"];
+
+        if (channelId !== envChannelId) {
+            sanityCheck = false;
+            console.log(`
+⛔ Sanity check failed for network ${networkName}, 
+check if the channel id value for the Universal channel in the config is correct.
+--------------------------------------------------
+🔮 Expected Channel ID (in Universal Channel Handler contract): ${channelId}...
+🗃️  Found Dispatcher (in .env file): ${envChannelId}...
+--------------------------------------------------
+`);
+            return;
+        }
+    }
+
+    // 5. Print the result of the sanity check
+    // If true, it means all values in the contracts check out with those in the .env file and we can continue with the script.
+    if (sanityCheck) {
+        console.log(`✅ Sanity check passed for network ${networkName}`);
+    } else {    
+        console.log(`
+⛔ Sanity check failed for network ${networkName}, 
+check if the values provided in the .env file for the Universal Channel Mw and the dispatcher are correct.
+--------------------------------------------------
+🔮 Expected Dispatcher (in Universal Channel Handler contract): ${dispatcherAddr}...
+🗃️  Found Dispatcher (in .env file): ${envDispatcherAddr}...
+--------------------------------------------------
+`);
+    }
+}
+
+// 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/_sanity-check.js

@@ -0,0 +1,21 @@
+// Example: 
+// $ node scripts/sanity-check.js
+const { exec } = require("child_process");
+const { getConfigPath } = require('./_helpers.js');
+
+function runSanityCheck(network) {
+    const config = require(getConfigPath());
+    const scriptSuffix = config.isUniversal ? 'universal' : 'custom';
+    
+    exec(`npx hardhat run scripts/private/_sanity-check-${scriptSuffix}.js --network ${network}`, (error, stdout, stderr) => {
+        if (error) {
+        console.error(`exec error: ${error}`);
+        return;
+        }
+        console.log(stdout);
+     });
+}
+
+// TODO: EXTEND THIS TO SUPPORT MULTIPLE NETWORKS
+runSanityCheck('optimism');
+runSanityCheck('base');

package/polymer/polymer-template/scripts/private/_send-packet-config.js

@@ -0,0 +1,53 @@
+const { exec } = require("child_process");
+const {getConfigPath, getWhitelistedNetworks} = require('./_helpers.js');
+const { setupIbcPacketEventListener } = require('./_events.js');
+
+const source = process.argv[2];
+if (!source) {
+  console.error('Usage: node send-packet-config.js <source_network>');
+  process.exit(1);
+}
+
+function runSendPacket(config) {
+  // Check if the source chain from user input is whitelisted
+  const allowedNetworks = getWhitelistedNetworks();
+  if (!allowedNetworks.includes(source)) {
+    console.error("❌ Please provide a valid source chain");
+    process.exit(1);
+  }
+
+  // Run the send-packet or send-universal-packet script based on the config
+  if (config.isUniversal) {
+    exec(`npx hardhat run scripts/send-universal-packet.js --network ${source}`, (error, stdout, stderr) => {
+        if (error) {
+          console.error(`exec error: ${error}`);
+          return;
+        } else {
+          console.log(stdout);
+        }
+    });
+  } else {
+    exec(`npx hardhat run scripts/send-packet.js --network ${source}`, (error, stdout, stderr) => {
+        if (error) {
+          console.error(`exec error: ${error}`);
+          return;
+        }else {
+          console.log(stdout);
+        }
+    });
+  }
+}
+
+async function main() {
+  const configPath = getConfigPath();
+  const config = require(configPath);
+
+  await setupIbcPacketEventListener();
+
+  runSendPacket(config);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/polymer/polymer-template/scripts/private/_set-contracts-config.js

@@ -0,0 +1,50 @@
+// Run script to set the contract in the config.json file along with the isUniversal flag
+// Example: 
+// $ node set-contracts-config.js optimism XCounterUC true
+const fs = require('fs');
+const { getConfigPath } = require('./_helpers.js');
+
+if(process.argv.length < 5) {
+  console.error('❌ Incorrect number of args. Usage: node set-contracts-config.js <chain> <contractType> <isUniversal>');
+  process.exit(1);
+}
+const chain = process.argv[2];
+const contractType = process.argv[3];
+const universalBoolean = process.argv[4].trim().toLowerCase()
+
+if (chain !== "optimism" && chain !== "base") {
+  console.error('❌ Incorrect chain value. Usage: node set-contracts-config.js <chain> <contractType> <isUniversal>');
+  process.exit(1);
+}
+
+let isUniversal;
+if (universalBoolean === "true") {
+  isUniversal = true;
+} else if (universalBoolean === "false") {
+  isUniversal = false;
+} else {
+  console.error('❌ Incorrect boolean value. Usage: node set-contracts-config.js <chain> <contractType> <isUniversal>');
+  process.exit(1);
+}
+
+const configPath = getConfigPath();
+
+// Function to update config.json
+function updateConfig(network, contractType) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      
+      // Update the config object
+      config["deploy"][`${network}`] = contractType;
+      config["isUniversal"] = isUniversal;
+    
+      // Write the updated config back to the file
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log(`🆗 Updated config with ${contractType} for ${network}. Set isUniversal to ${isUniversal}.`);
+    } catch (error) {
+      console.error(`❌ Failed to update config: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  updateConfig(chain, contractType);

package/polymer/polymer-template/scripts/private/_switch-clients.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const { getConfigPath } = require('./_helpers.js');
+const ibcConfig = require('../../ibc.json');
+
+// Function to update config.json
+function flipConfig() {
+    try {
+        const configPath = getConfigPath();
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        // Create a temporary copy of the config object to store a backup of the current values
+        // The backup is used when switching back to between clients
+        const tempConfig = {...config};
+        const source = tempConfig["createChannel"]["srcChain"];
+        const destination = tempConfig["createChannel"]["dstChain"];
+    
+        // Below, we'll update the config object
+        if (config.backup !== undefined && typeof config.backup === 'object' && Object.keys(config.backup).length > 0) {
+            // Update the createChannel object with backup values 
+            config["createChannel"]["srcAddr"] = config["backup"]["sendPacket"][`${source}`]["portAddr"];
+            config["createChannel"]["dstAddr"] = config["backup"]["sendPacket"][`${destination}`]["portAddr"];
+
+            // Update the sendPacket and sendUniversalPacket object with backup values
+            config["sendPacket"] = config["backup"]["sendPacket"];
+            config["sendUniversalPacket"] = config["backup"]["sendUniversalPacket"];
+        } else {
+            // If no backup object is provided, use the default values
+            config["createChannel"] = {
+                "srcChain": source,
+                "srcAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
+                "dstChain": destination,
+                "dstAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
+                "version": "1.0",
+                "ordering": 0,
+                "fees": false
+              };
+              config["sendPacket"] = {
+                "optimism": {
+                    "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
+                    "channelId": "channel-n",
+                    "timeout": 36000
+                  },
+                  "base": {
+                    "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
+                    "channelId": "channel-n",
+                    "timeout": 36000
+                  }
+                };
+                config["sendUniversalPacket"] = {
+                    "optimism": {
+                        "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
+                        "channelId": "channel-x",
+                        "timeout": 36000
+                      },
+                      "base": {
+                        "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
+                        "channelId": "channel-y",
+                        "timeout": 36000
+                      }
+                    };
+        }
+
+        // Update the universal channel values for new client
+        config["sendUniversalPacket"]["optimism"]["channelId"] = 
+            tempConfig.proofsEnabled ?
+            ibcConfig["optimism"]["sim-client"]["universalChannel"] :
+            ibcConfig["optimism"]["op-client"]["universalChannel"];
+        config["sendUniversalPacket"]["base"]["channelId"] =
+            tempConfig.proofsEnabled ?
+            ibcConfig["base"]["sim-client"]["universalChannel"] :
+            ibcConfig["base"]["op-client"]["universalChannel"];
+        
+        // Write a new backup object to the config
+        config["backup"] = {
+            "sendPacket": tempConfig["sendPacket"],
+            "sendUniversalPacket": tempConfig["sendUniversalPacket"]
+        };
+
+        // Flip the proofsEnabled flag
+        config["proofsEnabled"] = !config["proofsEnabled"];
+
+        // Write the updated config back to the file
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log('🆗 Config updated');
+    } catch (error) {
+        console.error(`❌ Failed to update config: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+flipConfig();

package/polymer/polymer-template/scripts/private/_update-vibc-address.js

@@ -0,0 +1,52 @@
+// 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 { getDispatcherAddress, getUcHandlerAddress, getIbcApp } = require("./_vibc-helpers");
+const { getConfigPath } = require("./_helpers");
+
+async function main() {
+    await hre.ethers.getSigners();
+    const networkName = hre.network.name;
+    const config = require(getConfigPath());
+
+    if (!config.isUniversal) {
+        // Determine the new dispatcher, based on the network.
+        const newDispatcher = getDispatcherAddress(networkName);
+
+        // Get the contract type from the config and get the contract
+        const ibcApp = await getIbcApp(networkName);
+        try {
+            await ibcApp.updateDispatcher(newDispatcher);
+        } catch (error) { 
+            console.error(`❌ Error getting dispatcher address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
+            return;
+        }
+        console.log(`✅ Dispatcher updated to ${newDispatcher}`);
+    } else if (config.isUniversal) {
+        // Determine the new universal channel handler, based on the network.
+        const newUcHandler = getUcHandlerAddress(networkName);
+
+        // Get the contract type from the config and get the contract
+        const ibcApp = await getIbcApp(networkName, true);
+        try {
+            await ibcApp.setDefaultMw(newUcHandler);
+        } catch (error) {
+            console.log(`❌ Error updating Universal Channel Mw address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
+            return;
+        }
+        console.log(`✅ Universal channel handler updated to ${newUcHandler}`);
+    }else {
+        console.error('❌ Check the config file for isUniversal value. It should be a boolean.');
+    };
+}
+
+// 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/_vibc-helpers.js

@@ -0,0 +1,118 @@
+const {ethers} = require("hardhat");
+const { getConfigPath, fetchABI} = require("./_helpers.js");
+
+const explorerOpUrl = "https://optimism-sepolia.blockscout.com/";
+const explorerBaseUrl = "https://base-sepolia.blockscout.com/";
+
+const rpcOptimism = `https://opt-sepolia.g.alchemy.com/v2/${process.env.OP_ALCHEMY_API_KEY}`;
+const rpcBase = `https://base-sepolia.g.alchemy.com/v2/${process.env.BASE_ALCHEMY_API_KEY}`;
+
+async function getIbcApp (network) {
+    try {
+        const config = require(getConfigPath());
+        const ibcAppAddr = config.isUniversal ? config["sendUniversalPacket"][`${network}`]["portAddr"] : config["sendPacket"][`${network}`]["portAddr"];
+        console.log(`🗄️  Fetching IBC app on ${network} at address: ${ibcAppAddr}`)
+        const contractType = config["deploy"][`${network}`];
+        const ibcApp = await ethers.getContractAt(
+            `${contractType}`,
+            ibcAppAddr
+        );
+        return ibcApp;
+    } catch (error) {
+        console.log(`❌ Error getting IBC app: ${error}`);
+        return;
+    }
+  }
+
+function getDispatcherAddress(network) {
+    const config = require(getConfigPath());
+    let dispatcherAddr;
+    if (network === "optimism") {
+        dispatcherAddr = config.proofsEnabled ? process.env.OP_DISPATCHER : process.env.OP_DISPATCHER_SIM;
+    } else if (network === "base") {
+        dispatcherAddr = config.proofsEnabled ? process.env.BASE_DISPATCHER : process.env.BASE_DISPATCHER_SIM;
+    } else {
+        throw new Error("❌ Invalid network");
+    }
+    return dispatcherAddr;
+}
+
+async function getDispatcher (network) {
+    const config = require(getConfigPath());
+    const providerOptimism = new ethers.JsonRpcProvider(rpcOptimism);
+    const providerBase = new ethers.JsonRpcProvider(rpcBase);
+
+    let explorerUrl;
+    let dispatcher;
+    let dispatcherAddress;
+    try {
+        if (network === "optimism") {
+            explorerUrl = explorerOpUrl;
+            dispatcherAddress = config.proofsEnabled ? dispatcherAddress = process.env.OP_DISPATCHER : dispatcherAddress = process.env.OP_DISPATCHER_SIM;
+
+            const opDispatcherAbi = await fetchABI(explorerUrl, dispatcherAddress);
+            dispatcher = new ethers.Contract(dispatcherAddress, opDispatcherAbi, providerOptimism);
+        } else if (network === "base") {
+            explorerUrl = explorerBaseUrl;
+            dispatcherAddress = config.proofsEnabled ? dispatcherAddress = process.env.BASE_DISPATCHER : dispatcherAddress = process.env.BASE_DISPATCHER_SIM;
+
+            const baseDispatcherAbi = await fetchABI(explorerUrl, dispatcherAddress);
+            dispatcher = new ethers.Contract(dispatcherAddress, baseDispatcherAbi, providerBase);
+        } else {
+            throw new Error(`❌ Invalid network: ${network}`);
+        }
+        return dispatcher;
+    }
+    catch (error) {
+        console.log(`❌ Error getting dispatcher: ${error}`);
+        return;
+    }
+}
+
+function getUcHandlerAddress(network) {
+    const config = require(getConfigPath());
+    let ucHandlerAddr;
+    if (network === "optimism") {
+        ucHandlerAddr = config.proofsEnabled ? process.env.OP_UC_MW : process.env.OP_UC_MW_SIM;
+    } else if (network === "base") {
+        ucHandlerAddr = config.proofsEnabled ? process.env.BASE_UC_MW : process.env.BASE_UC_MW_SIM;
+    } else {
+        throw new Error("❌ Invalid network");
+    }
+    return ucHandlerAddr;
+}
+
+async function getUcHandler (network) {
+    const config = require(getConfigPath());
+    const providerOptimism = new ethers.JsonRpcProvider(rpcOptimism);
+    const providerBase = new ethers.JsonRpcProvider(rpcBase);
+
+    let explorerUrl;
+    let ucHandler;
+    let ucHandlerAddress;
+
+    try {
+        if (network === "optimism") {
+            explorerUrl = explorerOpUrl;
+            ucHandlerAddress = config.proofsEnabled ? process.env.OP_UC_MW : process.env.OP_UC_MW_SIM;
+
+            const opUcHandlerAbi = await fetchABI(explorerUrl, ucHandlerAddress);
+            ucHandler = new ethers.Contract(ucHandlerAddress, opUcHandlerAbi, providerOptimism);
+        } else if (network === "base") {
+            explorerUrl = explorerBaseUrl;
+            ucHandlerAddress = config.proofsEnabled ? process.env.BASE_UC_MW : process.env.BASE_UC_MW_SIM;
+
+            const baseUcHandlerAbi = await fetchABI(explorerUrl, ucHandlerAddress);
+            ucHandler = new ethers.Contract(ucHandlerAddress, baseUcHandlerAbi, providerBase);
+        } else {
+            throw new Error(`❌ Invalid network: ${network}`);
+        }
+
+        return ucHandler;
+    } catch (error) {
+        console.log(`❌ Error getting ucHandler: ${error}`);
+        return;
+    }
+}
+
+module.exports = { getIbcApp, getDispatcherAddress, getDispatcher, getUcHandlerAddress, getUcHandler };

package/polymer/polymer-template/scripts/send-packet.js

@@ -0,0 +1,38 @@
+// 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');
+const { getIbcApp } = require('./private/_vibc-helpers.js');
+
+async function main() {
+    const accounts = await hre.ethers.getSigners();
+    const config = require(getConfigPath());
+    const sendConfig = config.sendPacket;
+
+    const networkName = hre.network.name;
+    // Get the contract type from the config and get the contract
+    const ibcApp = await getIbcApp(networkName);
+
+    // Do logic to prepare the packet
+    const channelId = sendConfig[`${networkName}`]["channelId"];
+    const channelIdBytes = hre.ethers.encodeBytes32String(channelId);
+    const timeoutSeconds = sendConfig[`${networkName}`]["timeout"];
+    
+    // Send the packet
+    await ibcApp.connect(accounts[0]).sendPacket(
+        channelIdBytes,
+        timeoutSeconds,
+        // Define and pass optionalArgs appropriately or remove if not needed    
+        );
+}
+
+// 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/send-universal-packet.js

@@ -0,0 +1,44 @@
+// 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');
+const { getIbcApp } = require('./private/_vibc-helpers.js');
+
+async function main() {
+    const accounts = await hre.ethers.getSigners();
+    const config = require(getConfigPath());
+    const sendConfig = config.sendUniversalPacket;
+
+    const networkName = hre.network.name;
+    // Get the contract type from the config and get the contract
+    const ibcApp = await getIbcApp(networkName);
+
+    // Do logic to prepare the packet
+
+    // If the network we are sending on is optimism, we need to use the base port address and vice versa
+    const destPortAddr = networkName === "optimism" ?
+      config["sendUniversalPacket"]["base"]["portAddr"] :
+      config["sendUniversalPacket"]["optimism"]["portAddr"];
+    const channelId = sendConfig[`${networkName}`]["channelId"];
+    const channelIdBytes = hre.ethers.encodeBytes32String(channelId);
+    const timeoutSeconds = sendConfig[`${networkName}`]["timeout"];
+    
+    // Send the packet
+    await ibcApp.connect(accounts[0]).sendUniversalPacket(
+        destPortAddr,
+        channelIdBytes,
+        timeoutSeconds,
+        // Define and pass optionalArgs appropriately or remove if not needed
+    );
+}
+
+// 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;
+});