├── img
    └── gh_template.png
├── foundry.toml
├── remappings.txt
├── .gitmodules
├── .gitignore
├── scripts
    ├── private
    │   ├── _sanity-check.js
    │   ├── _send-packet-config.js
    │   ├── _set-contracts-config.js
    │   ├── _send-vote-info-config.js
    │   ├── _deploy-config.js
    │   ├── _create-channel-config.js
    │   ├── _update-vibc-address.js
    │   ├── _sanity-check-custom.js
    │   ├── _create-channel.js
    │   ├── _switch-clients.js
    │   ├── _helpers.js
    │   ├── _vibc-helpers.js
    │   ├── _sanity-check-universal.js
    │   └── _events.js
    ├── send-packet.js
    ├── send-universal-packet.js
    ├── x-ballot-nft
    │   ├── send-vote-info.js
    │   ├── send-universal-vote-info.js
    │   ├── _app-events-UC.js
    │   └── _app-events.js
    └── deploy.js
├── ibc.json
├── contracts
    ├── arguments.js
    ├── x-ballot-nft
    │   ├── XProofOfVoteNFT.sol
    │   └── XBallot.sol
    ├── x-ballot-nft-UC
    │   ├── XProofOfVoteNFTUC.sol
    │   └── XBallotUC.sol
    ├── XCounter.sol
    ├── XCounterUC.sol
    └── base
    │   ├── UniversalChanIbcApp.sol
    │   ├── GeneralMiddleware.sol
    │   └── CustomChanIbcApp.sol
├── package.json
├── .env.example
├── config.json
├── config
    ├── x-ballot-nft-UC.json
    └── x-ballot-nft.json
├── hardhat.config.js
├── Justfile
├── README.md
└── ibc-app-template.md


/img/gh_template.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/polymerdao/demo-dapps/HEAD/img/gh_template.png


--------------------------------------------------------------------------------
/foundry.toml:
--------------------------------------------------------------------------------
1 | [profile.default]
2 | src = 'contracts'
3 | out = 'out'
4 | libs = ['node_modules', 'lib']
5 | test = 'test'
6 | cache_path  = 'cache_forge'


--------------------------------------------------------------------------------
/remappings.txt:
--------------------------------------------------------------------------------
1 | @open-ibc/vibc-core-smart-contracts/=lib/vibc-core-smart-contracts/
2 | @lazyledger/protobuf3-solidity-lib/=lib/protobuf3-solidity-lib/
3 | ds-test/=lib/forge-std/lib/ds-test/src/
4 | forge-std/=lib/forge-std/src/
5 | 
6 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "lib/vibc-core-smart-contracts"]
2 | 	path = lib/vibc-core-smart-contracts
3 | 	url = https://github.com/open-ibc/vibc-core-smart-contracts
4 | [submodule "lib/forge-std"]
5 | 	path = lib/forge-std
6 | 	url = https://github.com/foundry-rs/forge-std
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | node_modules
 2 | .env
 3 | 
 4 | # Hardhat files
 5 | /cache
 6 | /artifacts
 7 | 
 8 | # TypeChain files
 9 | /typechain
10 | /typechain-types
11 | 
12 | # solidity-coverage files
13 | /coverage
14 | /coverage.json
15 | 
16 | # Foundry files
17 | /out
18 | /cache_forge


--------------------------------------------------------------------------------
/scripts/private/_sanity-check.js:
--------------------------------------------------------------------------------
 1 | // Example: 
 2 | // $ node scripts/sanity-check.js
 3 | const { exec } = require("child_process");
 4 | const { getConfigPath } = require('./_helpers.js');
 5 | 
 6 | function runSanityCheck(network) {
 7 |     const config = require(getConfigPath());
 8 |     const scriptSuffix = config.isUniversal ? 'universal' : 'custom';
 9 |     
10 |     exec(`npx hardhat run scripts/private/_sanity-check-${scriptSuffix}.js --network ${network}`, (error, stdout, stderr) => {
11 |         if (error) {
12 |         console.error(`exec error: ${error}`);
13 |         return;
14 |         }
15 |         console.log(stdout);
16 |      });
17 | }
18 | 
19 | // TODO: EXTEND THIS TO SUPPORT MULTIPLE NETWORKS
20 | runSanityCheck('optimism');
21 | runSanityCheck('base');


--------------------------------------------------------------------------------
/ibc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "optimism": {
 3 |         "sim-client": {
 4 |             "canonConnFrom": "connection-0",
 5 |             "canonConnTo": "connection-1",
 6 |             "universalChannel": "channel-10"
 7 |         },
 8 |         "op-client": {
 9 |             "canonConnFrom": "connection-8",
10 |             "canonConnTo": "connection-9",
11 |             "universalChannel": "channel-16"
12 |         }
13 |     },
14 |     "base": {
15 |         "sim-client" : {
16 |             "canonConnFrom": "connection-4",
17 |             "canonConnTo": "connection-5",
18 |             "universalChannel": "channel-11"
19 |         },
20 |         "op-client": {
21 |             "canonConnFrom": "connection-10",
22 |             "canonConnTo": "connection-11",
23 |             "universalChannel": "channel-17"
24 |         }
25 |     }
26 | }


--------------------------------------------------------------------------------
/contracts/arguments.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |     "XCounter": [],
 3 |     "XCounterUC": [],
 4 |     // Add your contract types here, along with the list of custom constructor arguments
 5 |     // DO NOT ADD THE DISPATCHER OR UNIVERSAL CHANNEL HANDLER ADDRESSES HERE!!!
 6 |     // These will be added in the deploy script at $ROOT/scripts/deploy.js
 7 |     "XBallot": [
 8 |         [
 9 |             '0x506f6c796d657220697320612062726964676500000000000000000000000000',   // "Polymer is a bridge"
10 |             '0x506f6c796d6572206973206e6f74206120627269646765000000000000000000'    // "Polymer is not a bridge"
11 |         ]
12 |     ],
13 |     "XProofOfVoteNFT": [
14 |         'https://picsum.photos/id/'
15 |     ],
16 |     "XBallotUC": [
17 |         [
18 |             '0x506f6c796d657220697320612062726964676500000000000000000000000000',   // "Polymer is a bridge"
19 |             '0x506f6c796d6572206973206e6f74206120627269646765000000000000000000'    // "Polymer is not a bridge"
20 |         ]
21 |     ],
22 |     "XProofOfVoteNFTUC": [
23 |         'https://picsum.photos/id/'
24 |     ]    
25 | };


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ibc-app-solidity-template",
 3 |   "version": "1.0.0",
 4 |   "description": "Template project to start building IBC enabled Solidity contracts, with Hardhat and Foundry support",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "git+https://github.com/open-ibc/ibc-app-solidity-template.git"
12 |   },
13 |   "keywords": [
14 |     "IBC",
15 |     "Solidity"
16 |   ],
17 |   "author": "Polymer Labs",
18 |   "license": "MIT",
19 |   "bugs": {
20 |     "url": "https://github.com/open-ibc/ibc-app-solidity-template/issues"
21 |   },
22 |   "homepage": "https://github.com/open-ibc/ibc-app-solidity-template#readme",
23 |   "devDependencies": {
24 |     "@nomicfoundation/hardhat-foundry": "^1.1.1",
25 |     "@nomicfoundation/hardhat-toolbox": "^4.0.0",
26 |     "hardhat": "^2.19.5"
27 |   },
28 |   "dependencies": {
29 |     "@openzeppelin/contracts": "^4.7.6",
30 |     "axios": "^1.6.7",
31 |     "dotenv": "^16.4.1",
32 |     "hardhat-verify": "^1.0.0"
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
 1 | # Make sure to rename this file to .env before adding your private keys!!!
 2 | PRIVATE_KEY_1=''
 3 | PRIVATE_KEY_2=''
 4 | PRIVATE_KEY_3=''
 5 | # Add more if your project requires more private keys
 6 | 
 7 | # API keys for developer tooling and infra
 8 | OP_ALCHEMY_API_KEY=''
 9 | BASE_ALCHEMY_API_KEY=''
10 | OP_BLOCKSCOUT_API_KEY=''
11 | BASE_BLOCKSCOUT_API_KEY=''
12 | # TENDERLY_TOKEN=''
13 | 
14 | # Contract addresses last updated on 2024-03-05, for public testnet launch
15 | OP_DISPATCHER='0x58f1863f75c9db1c7266dc3d7b43832b58f35e83'
16 | BASE_DISPATCHER='0xfc1d3e02e00e0077628e8cc9edb6812f95db05dc'
17 | 
18 | OP_UC_MW='0x34a0e37cCCEdaC70EC1807e5a1f6A4a91D4AE0Ce'
19 | BASE_UC_MW='0x50E32e236bfE4d514f786C9bC80061637dd5AF98'
20 | 
21 | # Contract addresses for the sim-client
22 | OP_DISPATCHER_SIM="0x6C9427E8d770Ad9e5a493D201280Cc178125CEc0"
23 | BASE_DISPATCHER_SIM="0x0dE926fE2001B2c96e9cA6b79089CEB276325E9F"
24 | 
25 | OP_UC_MW_SIM='0xC3318ce027C560B559b09b1aA9cA4FEBDDF252F5'
26 | BASE_UC_MW_SIM='0x5031fb609569b67608Ffb9e224754bb317f174cD'
27 | 
28 | # Configuration file the scripts will use, defaulting to config.json when not set
29 | CONFIG_PATH='config.json'


--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "proofsEnabled": false,
 3 |   "deploy": {
 4 |     "optimism": "XCounterUC",
 5 |     "base": "XCounterUC"
 6 |   },
 7 |   "isUniversal": true,
 8 |   "createChannel": {
 9 |     "srcChain": "optimism",
10 |     "srcAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
11 |     "dstChain": "base",
12 |     "dstAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
13 |     "version": "1.0",
14 |     "ordering": 0,
15 |     "fees": false
16 |   },
17 |   "sendPacket": {
18 |     "optimism": {
19 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
20 |       "channelId": "channel-n",
21 |       "timeout": 36000
22 |     },
23 |     "base": {
24 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
25 |       "channelId": "channel-n",
26 |       "timeout": 36000
27 |     }
28 |   },
29 |   "sendUniversalPacket": {
30 |     "optimism": {
31 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
32 |       "channelId": "channel-x",
33 |       "timeout": 36000
34 |     },
35 |     "base": {
36 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
37 |       "channelId": "channel-y",
38 |       "timeout": 36000
39 |     }
40 |   },
41 |   "backup": {}
42 | }


--------------------------------------------------------------------------------
/config/x-ballot-nft-UC.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "proofsEnabled": false,
 3 |   "deploy": {
 4 |     "optimism": "XBallotUC",
 5 |     "base": "XProofOfVoteNFTUC"
 6 |   },
 7 |   "isUniversal": true,
 8 |   "createChannel": {
 9 |     "srcChain": "optimism",
10 |     "srcAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
11 |     "dstChain": "base",
12 |     "dstAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
13 |     "version": "1.0",
14 |     "ordering": 0,
15 |     "fees": false
16 |   },
17 |   "sendPacket": {
18 |     "optimism": {
19 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
20 |       "channelId": "channel-n",
21 |       "timeout": 36000
22 |     },
23 |     "base": {
24 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
25 |       "channelId": "channel-n",
26 |       "timeout": 36000
27 |     }
28 |   },
29 |   "sendUniversalPacket": {
30 |     "optimism": {
31 |       "portAddr": "0x80FA9cB428b3873df748628Ca992194451473159",
32 |       "channelId": "channel-10",
33 |       "timeout": 36000
34 |     },
35 |     "base": {
36 |       "portAddr": "0x4EF4C3C0Fe45a24b531e36C53e1AbF962eDBCFEb",
37 |       "channelId": "channel-11",
38 |       "timeout": 36000
39 |     }
40 |   },
41 |   "backup": {}
42 | }


--------------------------------------------------------------------------------
/config/x-ballot-nft.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "proofsEnabled": false,
 3 |   "deploy": {
 4 |     "optimism": "XBallot",
 5 |     "base": "XProofOfVoteNFT"
 6 |   },
 7 |   "isUniversal": false,
 8 |   "createChannel": {
 9 |     "srcChain": "optimism",
10 |     "srcAddr": "0xC4B32EE322beA5F48b59b7B3A13B2281B7BA6244",
11 |     "dstChain": "base",
12 |     "dstAddr": "0x051A88c9fBe5934dfE3Af835D23592C2d8cca1fF",
13 |     "version": "1.0",
14 |     "ordering": 0,
15 |     "fees": false
16 |   },
17 |   "sendPacket": {
18 |     "optimism": {
19 |       "portAddr": "0xC4B32EE322beA5F48b59b7B3A13B2281B7BA6244",
20 |       "channelId": "channel-37224",
21 |       "timeout": 36000
22 |     },
23 |     "base": {
24 |       "portAddr": "0x051A88c9fBe5934dfE3Af835D23592C2d8cca1fF",
25 |       "channelId": "channel-37225",
26 |       "timeout": 36000
27 |     }
28 |   },
29 |   "sendUniversalPacket": {
30 |     "optimism": {
31 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
32 |       "channelId": "channel-x",
33 |       "timeout": 36000
34 |     },
35 |     "base": {
36 |       "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
37 |       "channelId": "channel-y",
38 |       "timeout": 36000
39 |     }
40 |   },
41 |   "backup": {}
42 | }


--------------------------------------------------------------------------------
/scripts/send-packet.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require('hardhat');
 8 | const { getConfigPath } = require('./private/_helpers');
 9 | const { getIbcApp } = require('./private/_vibc-helpers.js');
10 | 
11 | async function main() {
12 |     const accounts = await hre.ethers.getSigners();
13 |     const config = require(getConfigPath());
14 |     const sendConfig = config.sendPacket;
15 | 
16 |     const networkName = hre.network.name;
17 |     // Get the contract type from the config and get the contract
18 |     const ibcApp = await getIbcApp(networkName);
19 | 
20 |     // Do logic to prepare the packet
21 |     const channelId = sendConfig[`${networkName}`]["channelId"];
22 |     const channelIdBytes = hre.ethers.encodeBytes32String(channelId);
23 |     const timeoutSeconds = sendConfig[`${networkName}`]["timeout"];
24 |     
25 |     // Send the packet
26 |     await ibcApp.connect(accounts[0]).sendPacket(
27 |         channelIdBytes,
28 |         timeoutSeconds,
29 |         // Define and pass optionalArgs appropriately or remove if not needed    
30 |         );
31 | }
32 | 
33 | // We recommend this pattern to be able to use async/await everywhere
34 | // and properly handle errors.
35 | main().catch((error) => {
36 |   console.error(error);
37 |   process.exitCode = 1;
38 | });


--------------------------------------------------------------------------------
/scripts/private/_send-packet-config.js:
--------------------------------------------------------------------------------
 1 | const { exec } = require("child_process");
 2 | const {getConfigPath, getWhitelistedNetworks} = require('./_helpers.js');
 3 | const { setupIbcPacketEventListener } = require('./_events.js');
 4 | 
 5 | const source = process.argv[2];
 6 | if (!source) {
 7 |   console.error('Usage: node send-packet-config.js <source_network>');
 8 |   process.exit(1);
 9 | }
10 | 
11 | function runSendPacketCommand(command) {
12 |   return new Promise((resolve, reject) => {
13 |     exec(command, (error, stdout, stderr) => {
14 |       if (error) {
15 |         console.error(`exec error: ${error}`);
16 |         reject(error);
17 |       } else {
18 |         console.log(stdout);
19 |         resolve(true);
20 |       }
21 |     });
22 |   });
23 | }
24 | 
25 | async function runSendPacket(config) {
26 |   // Check if the source chain from user input is whitelisted
27 |   const allowedNetworks = getWhitelistedNetworks();
28 |   if (!allowedNetworks.includes(source)) {
29 |     console.error("❌ Please provide a valid source chain");
30 |     process.exit(1);
31 |   }
32 | 
33 |   const script = config.isUniversal ? 'send-universal-packet.js' : 'send-packet.js';
34 |   const command = `npx hardhat run scripts/${script} --network ${source}`;
35 | 
36 |   try {
37 |     await setupIbcPacketEventListener();
38 |     await runSendPacketCommand(command);
39 |   } catch (error) {
40 |     console.error("❌ Error sending packet: ", error);
41 |     process.exit(1);
42 |   }
43 | }
44 | 
45 | async function main() {
46 |   const configPath = getConfigPath();
47 |   const config = require(configPath);
48 | 
49 |   await runSendPacket(config);
50 | }
51 | 
52 | main().catch((error) => {
53 |   console.error(error);
54 |   process.exitCode = 1;
55 | });


--------------------------------------------------------------------------------
/hardhat.config.js:
--------------------------------------------------------------------------------
 1 | require("@nomicfoundation/hardhat-toolbox");
 2 | require("@nomicfoundation/hardhat-foundry");
 3 | 
 4 | require('dotenv').config();
 5 | 
 6 | /** @type import('hardhat/config').HardhatUserConfig */
 7 | module.exports = {
 8 |   solidity: {
 9 |     version: '0.8.23',
10 |     settings: {
11 |       optimizer: {
12 |         enabled: true,
13 |         runs: 200 // Optimize for a typical number of runs
14 |       }
15 |     }    
16 |   },
17 |   networks: {
18 |     // for Base testnet
19 |     'base': {
20 |       url: 'https://sepolia.base.org',
21 |       accounts: [
22 |         process.env.PRIVATE_KEY_1,
23 |         process.env.PRIVATE_KEY_2,
24 |         process.env.PRIVATE_KEY_3
25 |       ],
26 |     },
27 |     // for OP testnet
28 |     'optimism': {
29 |       url: 'https://sepolia.optimism.io',
30 |       accounts: [
31 |         process.env.PRIVATE_KEY_1,
32 |         process.env.PRIVATE_KEY_2,
33 |         process.env.PRIVATE_KEY_3
34 |       ],
35 |     },    
36 |   },
37 |   defaultNetwork: 'optimism',
38 |   paths: {
39 |     sources: './contracts',
40 |     tests: './test',
41 |     cache: './cache',
42 |     artifacts: './artifacts',
43 |     libraries: './lib',
44 |   },
45 |   etherscan: {
46 |     apiKey: {
47 |       optimism: process.env.OP_BLOCKSCOUT_API_KEY,
48 |       base: process.env.BASE_BLOCKSCOUT_API_KEY,
49 |     },
50 |     customChains: [
51 |       {
52 |         network: "base",
53 |         chainId: 84532,
54 |         urls: {
55 |           apiURL: "https://base-sepolia.blockscout.com/api",
56 |           browserURL: "https://base-sepolia.blockscout.com",
57 |         }
58 |       },
59 |       {
60 |         network: "optimism",
61 |         chainId: 11155420,
62 |         urls: {
63 |           apiURL: "https://optimism-sepolia.blockscout.com/api",
64 |           browserURL: "https://optimism-sepolia.blockscout.com",
65 |         }
66 |       }
67 |     ]
68 |   },
69 | };
70 | 
71 | 


--------------------------------------------------------------------------------
/scripts/private/_set-contracts-config.js:
--------------------------------------------------------------------------------
 1 | // Run script to set the contract in the config.json file along with the isUniversal flag
 2 | // Example: 
 3 | // $ node set-contracts-config.js optimism XCounterUC true
 4 | const fs = require('fs');
 5 | const { getConfigPath } = require('./_helpers.js');
 6 | 
 7 | if(process.argv.length < 5) {
 8 |   console.error('❌ Incorrect number of args. Usage: node set-contracts-config.js <chain> <contractType> <isUniversal>');
 9 |   process.exit(1);
10 | }
11 | const chain = process.argv[2];
12 | const contractType = process.argv[3];
13 | const universalBoolean = process.argv[4].trim().toLowerCase()
14 | 
15 | if (chain !== "optimism" && chain !== "base") {
16 |   console.error('❌ Incorrect chain value. Usage: node set-contracts-config.js <chain> <contractType> <isUniversal>');
17 |   process.exit(1);
18 | }
19 | 
20 | let isUniversal;
21 | if (universalBoolean === "true") {
22 |   isUniversal = true;
23 | } else if (universalBoolean === "false") {
24 |   isUniversal = false;
25 | } else {
26 |   console.error('❌ Incorrect boolean value. Usage: node set-contracts-config.js <chain> <contractType> <isUniversal>');
27 |   process.exit(1);
28 | }
29 | 
30 | const configPath = getConfigPath();
31 | 
32 | // Function to update config.json
33 | function updateConfig(network, contractType) {
34 |     try {
35 |       const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
36 |       
37 |       // Update the config object
38 |       config["deploy"][`${network}`] = contractType;
39 |       config["isUniversal"] = isUniversal;
40 |     
41 |       // Write the updated config back to the file
42 |       fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
43 |       console.log(`🆗 Updated config with ${contractType} for ${network}. Set isUniversal to ${isUniversal}.`);
44 |     } catch (error) {
45 |       console.error(`❌ Failed to update config: ${error.message}`);
46 |       process.exit(1);
47 |     }
48 |   }
49 | 
50 |   updateConfig(chain, contractType);


--------------------------------------------------------------------------------
/scripts/send-universal-packet.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require('hardhat');
 8 | const { getConfigPath } = require('./private/_helpers');
 9 | const { getIbcApp } = require('./private/_vibc-helpers.js');
10 | 
11 | async function main() {
12 |     const accounts = await hre.ethers.getSigners();
13 |     const config = require(getConfigPath());
14 |     const sendConfig = config.sendUniversalPacket;
15 | 
16 |     const networkName = hre.network.name;
17 |     // Get the contract type from the config and get the contract
18 |     const ibcApp = await getIbcApp(networkName);
19 | 
20 |     // Do logic to prepare the packet
21 | 
22 |     // If the network we are sending on is optimism, we need to use the base port address and vice versa
23 |     const destPortAddr = networkName === "optimism" ?
24 |       config["sendUniversalPacket"]["base"]["portAddr"] :
25 |       config["sendUniversalPacket"]["optimism"]["portAddr"];
26 |     const channelId = sendConfig[`${networkName}`]["channelId"];
27 |     const channelIdBytes = hre.ethers.encodeBytes32String(channelId);
28 |     const timeoutSeconds = sendConfig[`${networkName}`]["timeout"];
29 |     
30 |     // Send the packet
31 |     await ibcApp.connect(accounts[0]).sendUniversalPacket(
32 |         destPortAddr,
33 |         channelIdBytes,
34 |         timeoutSeconds,
35 |         // Define and pass optionalArgs appropriately or remove if not needed
36 |     );
37 | }
38 | 
39 | // We recommend this pattern to be able to use async/await everywhere
40 | // and properly handle errors.
41 | main().catch((error) => {
42 |   console.error(error);
43 |   process.exitCode = 1;
44 | });


--------------------------------------------------------------------------------
/scripts/x-ballot-nft/send-vote-info.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require('hardhat');
 8 | const { getConfigPath } = require('../private/_helpers.js');
 9 | const { getIbcApp } = require('../private/_vibc-helpers.js');
10 | 
11 | async function main() {
12 |     const accounts = await hre.ethers.getSigners();
13 |     const config = require(getConfigPath());
14 |     const sendConfig = config.sendPacket;
15 | 
16 |     const networkName = hre.network.name;
17 |     // Get the contract type from the config and get the contract
18 |     const ibcApp = await getIbcApp(networkName);
19 | 
20 |     // Change if your want to send a vote from a different address
21 |     const voteAccount = accounts[2];
22 | 
23 |     // console.log(`Casting a vote from address: ${voterAddress}`);
24 |     await ibcApp.connect(voteAccount).vote(1);
25 |     // console.log("Vote cast");
26 | 
27 |     // Do logic to prepare the packet
28 |     const channelId = sendConfig[`${networkName}`]["channelId"];
29 |     const channelIdBytes = hre.ethers.encodeBytes32String(channelId);
30 |     const timeoutSeconds = sendConfig[`${networkName}`]["timeout"];
31 |     const voterAddress = voteAccount.address;
32 |     const recipient = voterAddress;
33 |     
34 |     // Send the packet
35 |     // console.log(`Sending a packet via IBC to mint an NFT for ${recipient} related to vote from ${voterAddress}`);
36 |     await ibcApp.connect(accounts[0]).sendPacket(
37 |         channelIdBytes,
38 |         timeoutSeconds,
39 |         voterAddress,
40 |         recipient
41 |       );
42 | }
43 | 
44 | // We recommend this pattern to be able to use async/await everywhere
45 | // and properly handle errors.
46 | main().catch((error) => {
47 |   console.error(error);
48 |   process.exitCode = 1;
49 | });


--------------------------------------------------------------------------------
/scripts/private/_send-vote-info-config.js:
--------------------------------------------------------------------------------
 1 | const { exec } = require("child_process");
 2 | const {getConfigPath, getWhitelistedNetworks} = require('./_helpers.js');
 3 | const { setupIbcPacketEventListener } = require('./_events.js');
 4 | const { setupXBallotNFTEventListener } = require('../x-ballot-nft/_app-events.js');
 5 | const { setupUcXBallotNFTEventListener } = require('../x-ballot-nft/_app-events-UC.js');
 6 | 
 7 | function runSendPacketCommand(command) {
 8 |   return new Promise((resolve, reject) => {
 9 |     exec(command, (error, stdout, stderr) => {
10 |       if (error) {
11 |         console.error(`exec error: ${error}`);
12 |         reject(error);
13 |       } else {
14 |         console.log(stdout);
15 |         resolve(true);
16 |       }
17 |     });
18 |   });
19 | }
20 | 
21 | async function runSendPacket(config) {
22 |   const source = config.createChannel.srcChain;
23 | 
24 |   // Check if the source chain from user input is whitelisted
25 |   const allowedNetworks = getWhitelistedNetworks();
26 |   if (!allowedNetworks.includes(source)) {
27 |     console.error("❌ Please provide a valid source chain");
28 |     process.exit(1);
29 |   }
30 | 
31 |   const script = config.isUniversal ? 'send-universal-vote-info.js' : 'send-vote-info.js';
32 |   const command = `npx hardhat run scripts/x-ballot-nft/${script} --network ${source}`;
33 | 
34 |   try {
35 |     await setupIbcPacketEventListener();
36 |     if (config.isUniversal === true) {
37 |       await setupUcXBallotNFTEventListener();
38 |     } else if (config.isUniversal === false) {
39 |       await setupXBallotNFTEventListener();
40 |     } else {
41 |       console.error("❌ Invalid config value for isUniversal. Please check your config file.");
42 |       process.exit(1);
43 |     }
44 |     await runSendPacketCommand(command);
45 |   } catch (error) {
46 |     console.error("❌ Error sending packet: ", error);
47 |     process.exit(1);
48 |   }
49 | }
50 | 
51 | async function main() {
52 |   const configPath = getConfigPath();
53 |   const config = require(configPath);
54 | 
55 |   await runSendPacket(config);
56 | }
57 | 
58 | main().catch((error) => {
59 |   console.error(error);
60 |   process.exitCode = 1;
61 | });


--------------------------------------------------------------------------------
/scripts/private/_deploy-config.js:
--------------------------------------------------------------------------------
 1 | const { exec } = require("child_process");
 2 | const { updateConfigDeploy, getWhitelistedNetworks } = require('./_helpers');
 3 | 
 4 | // Run script with source and destination networks as arguments
 5 | // Example: 
 6 | // $ node deploy-config.js optimism base
 7 | const source = process.argv[2];
 8 | const destination = process.argv[3];
 9 | 
10 | if (!source || !destination) {
11 |   console.error('Usage: node deploy-config.js <source_network> <destination_network>');
12 |   process.exit(1);
13 | }
14 | 
15 | // Function to run the deploy script and capture output
16 | function deployAndCapture(network, isSource) {
17 |   const allowedNetworks = getWhitelistedNetworks();
18 |   if (!allowedNetworks.includes(network)) {
19 |     console.error('Invalid network. Please provide a valid network as an argument.');
20 |     return;
21 |   }
22 |   exec(`npx hardhat run scripts/deploy.js --network ${network}`, (error, stdout, stderr) => {
23 |     if (error) {
24 |       console.error(`exec error: ${error}`);
25 |       return;
26 |     } else {
27 |       console.log(stdout);
28 |     }
29 | 
30 |     // Process stdout to find the contract address and network
31 |     const output = stdout.trim();
32 |     const match = output.match(/Contract (\S+) deployed to (\S+) on network (\S+)/);
33 | 
34 |     if (match) {
35 |       const contractType = match[1];
36 |       const address = match[2];
37 |       const network = match[3];
38 | 
39 |       console.log(`
40 |           ✅   Deployment Successful   ✅
41 |           -------------------------------
42 |           📄 Contract Type: ${contractType}
43 |           📍 Address: ${address}
44 |           🌍 Network: ${network}
45 |           -------------------------------\n
46 |       `);
47 | 
48 |       // Update the config.json file
49 |       updateConfigDeploy(network, address, isSource);
50 |       console.log(`🆗 Updated ${process.env.CONFIG_PATH || 'config.json'} with address ${address} on network ${network}`);
51 |     } else {
52 |       console.error("❌ Could not find contract address and network in output");
53 |     }
54 |   });
55 | }
56 | 
57 | function main() {
58 |   deployAndCapture(source, true);
59 |   deployAndCapture(destination, false);
60 | }
61 | 
62 | main();
63 | 


--------------------------------------------------------------------------------
/scripts/x-ballot-nft/send-universal-vote-info.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require('hardhat');
 8 | const { getConfigPath } = require('../private/_helpers.js');
 9 | const { getIbcApp } = require('../private/_vibc-helpers.js');
10 | 
11 | async function main() {
12 |     const accounts = await hre.ethers.getSigners();
13 |     const config = require(getConfigPath());
14 |     const sendConfig = config.sendUniversalPacket;
15 | 
16 |     const networkName = hre.network.name;
17 |     // Get the contract type from the config and get the contract
18 |     const ibcApp = await getIbcApp(networkName);
19 | 
20 |     // Change if your want to send a vote from a different address
21 |     const voteAccount = accounts[2];
22 | 
23 |     // console.log(`Casting a vote from address: ${voterAddress}`);
24 |     await ibcApp.connect(voteAccount).vote(1);
25 |     // console.log("Vote cast");
26 | 
27 |     // Do logic to prepare the packet
28 |     const destPortAddr = sendConfig[`${networkName}`]["portAddr"];
29 |     const channelId = sendConfig[`${networkName}`]["channelId"];
30 |     const channelIdBytes = hre.ethers.encodeBytes32String(channelId);
31 |     const timeoutSeconds = sendConfig[`${networkName}`]["timeout"];
32 |     const voterAddress = voteAccount.address;
33 |     const recipient = voterAddress;
34 |     
35 |     // Send the packet
36 |     // console.log(`Sending a packet via IBC to mint an NFT for ${recipient} related to vote from ${voterAddress}`);
37 |     await ibcApp.connect(accounts[0]).sendUniversalPacket(
38 |         destPortAddr,
39 |         channelIdBytes,
40 |         timeoutSeconds,
41 |         voterAddress,
42 |         recipient
43 |       );
44 | }
45 | 
46 | // We recommend this pattern to be able to use async/await everywhere
47 | // and properly handle errors.
48 | main().catch((error) => {
49 |   console.error(error);
50 |   process.exitCode = 1;
51 | });


--------------------------------------------------------------------------------
/scripts/deploy.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require("hardhat");
 8 | const {getConfigPath} = require('./private/_helpers.js');
 9 | const { getDispatcherAddress, getUcHandlerAddress } = require('./private/_vibc-helpers.js');
10 | 
11 | async function main() {
12 |   const config = require(getConfigPath());
13 |   const argsObject = require('../contracts/arguments.js');
14 |   const networkName = hre.network.name;
15 | 
16 |   // The config should have a deploy object with the network name as the key and contract type as the value
17 |   const contractType = config["deploy"][`${networkName}`];
18 |   const args = argsObject[`${contractType}`];
19 |   if (!args) {
20 |      console.warn(`No arguments found for contract type: ${contractType}`);
21 |   }
22 | 
23 |   // TODO: update to switch statement when supporting more networks
24 |   let constructorArgs;
25 |   if (config.isUniversal) {
26 |     const ucHandlerAddr = getUcHandlerAddress(networkName);
27 |     constructorArgs = [ucHandlerAddr, ...(args ?? [])];
28 |   } else if (!config.isUniversal) {
29 |     const dispatcherAddr = getDispatcherAddress(networkName);
30 |     constructorArgs = [dispatcherAddr, ...(args ?? [])];
31 |   }
32 |   
33 |   // Deploy the contract
34 |   // NOTE: when adding additional args to the constructor, add them to the array as well
35 |   const myContract = await hre.ethers.deployContract(contractType, constructorArgs);
36 | 
37 |   await myContract.waitForDeployment();
38 | 
39 |   // NOTE: Do not change the output string, its output is formatted to be used in the deploy-config.js script
40 |   // to update the config.json file
41 |   console.log(
42 |     `Contract ${contractType} deployed to ${myContract.target} on network ${networkName}`
43 |   );
44 | }
45 | 
46 | // We recommend this pattern to be able to use async/await everywhere
47 | // and properly handle errors.
48 | main().catch((error) => {
49 |   console.error(error);
50 |   process.exitCode = 1;
51 | });


--------------------------------------------------------------------------------
/scripts/private/_create-channel-config.js:
--------------------------------------------------------------------------------
 1 | const { exec } = require("child_process");
 2 | const { getConfigPath, updateConfigCreateChannel, getWhitelistedNetworks } = require('./_helpers.js');
 3 | const { setupIbcChannelEventListener } = require('./_events.js');
 4 | 
 5 | // Function to run the deploy script and capture output
 6 | function createChannelAndCapture() {
 7 |   const config = require(getConfigPath());
 8 |   const srcChain = config.createChannel.srcChain;
 9 |   
10 |   // Check if the source chain from user input is whitelisted
11 |   const allowedNetworks = getWhitelistedNetworks();
12 |   if (!allowedNetworks.includes(srcChain)) {
13 |     console.error('❌ Invalid network name');
14 |     return;
15 |   }
16 |   exec(`npx hardhat run scripts/private/_create-channel.js --network ${srcChain}`, (error, stdout, stderr) => {
17 |     if (error) {
18 |       console.error(`exec error: ${error}`);
19 |       return;
20 |     }
21 | 
22 |     // Process stdout to find the contract address and network
23 |     const output = stdout.trim();
24 |     const match = output.match(/Channel created: (\S+) with portID (\S+) on network (\S+), Counterparty: (\S+) on network (\S+)/);
25 | 
26 |     if (match) {
27 |       const channel = match[1];
28 |       const portId = match[2];
29 |       const network = match[3];
30 |       const cpChannel = match[4];
31 |       const cpNetwork = match[5];
32 | 
33 |       console.log(`
34 |           🎊   Created Channel   🎊
35 |           -----------------------------------------
36 |           🛣️  Channel ID: ${channel}
37 |           🔗 Port ID: ${portId}
38 |           🌍 Network: ${network}
39 |           -----------------------------------------
40 |           🛣️  Counterparty Channel ID: ${cpChannel}
41 |           🪐 Counterparty Network: ${cpNetwork}
42 |           -----------------------------------------\n`
43 |         );
44 | 
45 |       // Update the config.json file
46 |       updateConfigCreateChannel(network, channel, cpNetwork, cpChannel);
47 |       console.log(`🆗 Updated config.json with ${channel} on network ${network} and ${cpChannel} on network ${cpNetwork}`);
48 |     } else {
49 |       console.error("❌ Could not find required parameters in output");
50 |     }
51 |   });
52 | }
53 | 
54 | async function main() {
55 |   await setupIbcChannelEventListener();
56 |   createChannelAndCapture();
57 | }
58 | 
59 | main().catch((error) => {
60 |   console.error(error);
61 |   process.exitCode = 1;
62 | });
63 | 


--------------------------------------------------------------------------------
/scripts/private/_update-vibc-address.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require("hardhat");
 8 | const { getDispatcherAddress, getUcHandlerAddress, getIbcApp } = require("./_vibc-helpers");
 9 | const { getConfigPath } = require("./_helpers");
10 | 
11 | async function main() {
12 |     await hre.ethers.getSigners();
13 |     const networkName = hre.network.name;
14 |     const config = require(getConfigPath());
15 | 
16 |     if (!config.isUniversal) {
17 |         // Determine the new dispatcher, based on the network.
18 |         const newDispatcher = getDispatcherAddress(networkName);
19 | 
20 |         // Get the contract type from the config and get the contract
21 |         const ibcApp = await getIbcApp(networkName);
22 |         try {
23 |             await ibcApp.updateDispatcher(newDispatcher);
24 |         } catch (error) { 
25 |             console.error(`❌ Error getting dispatcher address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
26 |             return;
27 |         }
28 |         console.log(`✅ Dispatcher updated to ${newDispatcher}`);
29 |     } else if (config.isUniversal) {
30 |         // Determine the new universal channel handler, based on the network.
31 |         const newUcHandler = getUcHandlerAddress(networkName);
32 | 
33 |         // Get the contract type from the config and get the contract
34 |         const ibcApp = await getIbcApp(networkName, true);
35 |         try {
36 |             await ibcApp.setDefaultMw(newUcHandler);
37 |         } catch (error) {
38 |             console.log(`❌ Error updating Universal Channel Mw address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
39 |             return;
40 |         }
41 |         console.log(`✅ Universal channel handler updated to ${newUcHandler}`);
42 |     }else {
43 |         console.error('❌ Check the config file for isUniversal value. It should be a boolean.');
44 |     };
45 | }
46 | 
47 | // We recommend this pattern to be able to use async/await everywhere
48 | // and properly handle errors.
49 | main().catch((error) => {
50 |     console.error(error);
51 |     process.exitCode = 1;
52 |   });


--------------------------------------------------------------------------------
/contracts/x-ballot-nft/XProofOfVoteNFT.sol:
--------------------------------------------------------------------------------
 1 | //SPDX-License-Identifier: UNLICENSED
 2 | 
 3 | pragma solidity ^0.8.9;
 4 | 
 5 | import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 6 | import "@openzeppelin/contracts/utils/Counters.sol";
 7 | import "@openzeppelin/contracts/utils/Strings.sol";
 8 | 
 9 | import '../base/CustomChanIbcApp.sol';
10 | 
11 | contract XProofOfVoteNFT is ERC721, CustomChanIbcApp {
12 |     using Counters for Counters.Counter;
13 |     Counters.Counter private currentTokenId;
14 | 
15 |     string baseURI;
16 |     string private suffix = "/500/500";
17 | 
18 |     event MintedOnRecv(bytes32 channelId, uint64 sequence, address indexed recipient, uint256 voteNFTId);
19 | 
20 |     constructor(IbcDispatcher _dispatcher, string memory _baseURI) 
21 |     CustomChanIbcApp(_dispatcher) ERC721("ProofOfVoteNFT", "PolyVote"){
22 |         baseURI = _baseURI;
23 |     }
24 | 
25 |     function mint(address recipient)
26 |         internal
27 |         returns (uint256)
28 |     {
29 |         currentTokenId.increment();
30 |         uint256 tokenId = currentTokenId.current();
31 |         _safeMint(recipient, tokenId);
32 |         return tokenId;
33 |     }
34 | 
35 |     function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
36 |         require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
37 | 
38 |         return string(abi.encodePacked(baseURI, Strings.toString(tokenId), suffix));
39 |     }
40 | 
41 |     function updateBaseURI(string memory _newBaseURI) public {
42 |         baseURI = _newBaseURI;
43 |     }
44 | 
45 |     // IBC methods
46 | 
47 |     // This contract only receives packets from the IBC dispatcher
48 | 
49 |     function onRecvPacket(IbcPacket memory packet) external override onlyIbcDispatcher returns (AckPacket memory ackPacket) {
50 |         recvedPackets.push(packet);
51 |         
52 |         // Decode the packet data
53 |         (address decodedVoter, address decodedRecipient) = abi.decode(packet.data, (address, address));
54 | 
55 |         // Mint the NFT
56 |         uint256 voteNFTid = mint(decodedRecipient);
57 |         emit MintedOnRecv(packet.dest.channelId, packet.sequence, decodedRecipient, voteNFTid);
58 | 
59 |         // Encode the ack data
60 |         bytes memory ackData = abi.encode(decodedVoter, voteNFTid);
61 | 
62 |         return AckPacket(true, ackData);
63 |     }
64 | 
65 |     function onAcknowledgementPacket(IbcPacket calldata, AckPacket calldata) external view override onlyIbcDispatcher {
66 |         require(false, "This contract should never receive an acknowledgement packet");
67 |     }
68 | 
69 |     function onTimeoutPacket(IbcPacket calldata) external view override onlyIbcDispatcher {
70 |         require(false, "This contract should never receive a timeout packet");
71 |     }
72 | }


--------------------------------------------------------------------------------
/contracts/x-ballot-nft-UC/XProofOfVoteNFTUC.sol:
--------------------------------------------------------------------------------
 1 | //SPDX-License-Identifier: UNLICENSED
 2 | 
 3 | pragma solidity ^0.8.9;
 4 | 
 5 | import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 6 | import "@openzeppelin/contracts/utils/Counters.sol";
 7 | import "@openzeppelin/contracts/utils/Strings.sol";
 8 | 
 9 | 
10 | import '../base/UniversalChanIbcApp.sol';
11 | 
12 | contract XProofOfVoteNFTUC is ERC721, UniversalChanIbcApp {
13 |     using Counters for Counters.Counter;
14 |     Counters.Counter private currentTokenId;
15 | 
16 |     string baseURI;
17 |     string private suffix = "/500/500";
18 | 
19 |     event MintedOnRecv(address srcPortAddr, address indexed recipient, uint256 voteNFTId);
20 | 
21 |     constructor(address _middleware, string memory _baseURI) 
22 |         ERC721("UniversalProofOfVoteNFT", "PolyVoteUniversal")
23 |         UniversalChanIbcApp(_middleware) {
24 |             baseURI = _baseURI;
25 |     }
26 | 
27 |     function mint(address recipient)
28 |         internal
29 |         returns (uint256)
30 |     {
31 |         currentTokenId.increment();
32 |         uint256 tokenId = currentTokenId.current();
33 |         _safeMint(recipient, tokenId);
34 |         return tokenId;
35 |     }
36 | 
37 |     function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
38 |         require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
39 | 
40 |         return string(abi.encodePacked(baseURI, Strings.toString(tokenId), suffix));
41 |     }
42 | 
43 |     function updateTokenURI(string memory _newBaseURI) public {
44 |         baseURI = _newBaseURI;
45 |     }
46 | 
47 |     // IBC methods
48 | 
49 |     function onRecvUniversalPacket(
50 |         bytes32 channelId,
51 |         UniversalPacket calldata packet
52 |     ) external override onlyIbcMw returns (AckPacket memory ackPacket) {
53 |         recvedPackets.push(UcPacketWithChannel(channelId, packet));
54 | 
55 |         // Decode the packet data
56 |         (address decodedVoter, address decodedRecipient) = abi.decode(packet.appData, (address, address));
57 | 
58 |         // Mint the NFT
59 |         uint256 voteNFTid = mint(decodedRecipient);
60 |         emit MintedOnRecv(IbcUtils.toAddress(packet.srcPortAddr), decodedRecipient, voteNFTid);
61 | 
62 |         // Encode the ack data
63 |         bytes memory ackData = abi.encode(decodedVoter, voteNFTid);
64 | 
65 |         return AckPacket(true, ackData);
66 |     }
67 | 
68 |     function onUniversalAcknowledgement(
69 |             bytes32,
70 |             UniversalPacket memory,
71 |             AckPacket calldata
72 |     ) external override view onlyIbcMw {
73 |         require(false, "This function should not be called");
74 |     }
75 | 
76 |     function onTimeoutUniversalPacket(
77 |         bytes32, 
78 |         UniversalPacket calldata
79 |     ) external override view onlyIbcMw {
80 |         require(false, "This function should not be called");
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/scripts/private/_sanity-check-custom.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require("hardhat");
 8 | const { getConfigPath } = require('./_helpers');
 9 | const { areAddressesEqual } = require("./_helpers");
10 | const { getIbcApp } = require("./_vibc-helpers");
11 | 
12 | async function main() {
13 |     const configPath = getConfigPath();
14 |     const config = require(configPath);
15 |     const accounts = await hre.ethers.getSigners();
16 |     const networkName = hre.network.name;
17 | 
18 |     // Get the Dispatcher from your IBC enabled contract and compare it with the stored value in the .env file
19 | 
20 |     // 1. Get the contract type from the config and get the contract
21 |     const ibcApp = await getIbcApp(networkName);
22 | 
23 |     // 2. Query your contract for the Dispatcher address
24 |     let dispatcherAddr
25 |     try {
26 |         dispatcherAddr = await ibcApp.dispatcher();
27 |     } catch (error) { 
28 |         console.log(`❌ Error getting dispatcher address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
29 |         return;
30 |     }
31 | 
32 |     // 3. Compare with the value expected in the .env config file
33 |     let sanityCheck = false;
34 |     let envDispatcherAddr;
35 |     try {
36 |         if (networkName === "optimism") {
37 |             envDispatcherAddr = config.proofsEnabled === true ? process.env.OP_DISPATCHER : process.env.OP_DISPATCHER_SIM;
38 |             sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
39 |         } else if (networkName === "base") {
40 |             envDispatcherAddr = config.proofsEnabled === true ? process.env.BASE_DISPATCHER : process.env.BASE_DISPATCHER_SIM;
41 |             sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
42 |         }
43 |     } catch (error) {
44 |         console.log(`❌ Error comparing dispatcher addresses in .env file and IBC app: ${error}`);
45 |         return;
46 |     }
47 | 
48 |     // 4. Print the result of the sanity check 
49 |     // 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.
50 |     if (sanityCheck) {
51 |         console.log(`✅ Sanity check passed for network ${networkName}`);
52 |     } else {    
53 |         console.log(`
54 | ⛔ Sanity check failed for network ${networkName}, 
55 | check if the values provided in the .env file for the Universal Channel Mw and the dispatcher are correct.
56 | --------------------------------------------------
57 | 🔮 Expected dispatcher (in IBC contract): ${dispatcherAddr}...
58 | 🗃️ Found dispatcher (in .env file): ${envDispatcherAddr}...
59 | --------------------------------------------------
60 |         `);
61 |     }
62 | }
63 | 
64 | // We recommend this pattern to be able to use async/await everywhere
65 | // and properly handle errors.
66 | main().catch((error) => {
67 |     console.error(error);
68 |     process.exitCode = 1;
69 |   });


--------------------------------------------------------------------------------
/contracts/XCounter.sol:
--------------------------------------------------------------------------------
 1 | //SPDX-License-Identifier: UNLICENSED
 2 | 
 3 | pragma solidity ^0.8.9;
 4 | 
 5 | import './base/CustomChanIbcApp.sol';
 6 | 
 7 | contract XCounter is CustomChanIbcApp {
 8 |     // app specific state
 9 |     uint64 public counter;
10 |     mapping (uint64 => address) public counterMap;
11 | 
12 | 
13 |     constructor(IbcDispatcher _dispatcher) CustomChanIbcApp(_dispatcher) {}
14 | 
15 |     // app specific logic
16 |     function resetCounter() internal {
17 |         counter = 0;
18 |     }
19 | 
20 |     function increment() internal {
21 |         counter++;
22 |     }
23 | 
24 |     // IBC logic
25 | 
26 |     /**
27 |      * @dev Sends a packet with the caller address over a specified channel.
28 |      * @param channelId The ID of the channel (locally) to send the packet to.
29 |      * @param timeoutSeconds The timeout in seconds (relative).
30 |      */
31 | 
32 |     function sendPacket( bytes32 channelId, uint64 timeoutSeconds) external {
33 |         // incrementing counter on source chain
34 |         increment();
35 | 
36 |         // encoding the caller address to update counterMap on destination chain
37 |         bytes memory payload = abi.encode(msg.sender);
38 | 
39 |         // setting the timeout timestamp at 10h from now
40 |         uint64 timeoutTimestamp = uint64((block.timestamp + timeoutSeconds) * 1000000000);
41 | 
42 |         // calling the Dispatcher to send the packet
43 |         dispatcher.sendPacket(channelId, payload, timeoutTimestamp);
44 |     }
45 | 
46 |     /**
47 |      * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
48 |      *      MUST be overriden by the inheriting contract.
49 |      * 
50 |      * @param packet the IBC packet encoded by the source and relayed by the relayer.
51 |      */
52 |     function onRecvPacket(IbcPacket memory packet) external override onlyIbcDispatcher returns (AckPacket memory ackPacket) {
53 |         recvedPackets.push(packet);
54 |         address _caller = abi.decode(packet.data, (address));
55 |         counterMap[packet.sequence] = _caller;
56 | 
57 |         increment();
58 | 
59 |         return AckPacket(true, abi.encode(counter));
60 |     }
61 | 
62 |     /**
63 |      * @dev Packet lifecycle callback that implements packet acknowledgment logic.
64 |      *      MUST be overriden by the inheriting contract.
65 |      * 
66 |      * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
67 |      */
68 |     function onAcknowledgementPacket(IbcPacket calldata, AckPacket calldata ack) external override onlyIbcDispatcher {
69 |         ackPackets.push(ack);
70 |         
71 |         (uint64 _counter) = abi.decode(ack.data, (uint64));
72 |         
73 |        if (_counter != counter) {
74 |         resetCounter();
75 |        }
76 |     }
77 | 
78 |     /**
79 |      * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
80 |      *      MUST be overriden by the inheriting contract.
81 |      *      NOT SUPPORTED YET
82 |      * 
83 |      * @param packet the IBC packet encoded by the counterparty and relayed by the relayer
84 |      */
85 |     function onTimeoutPacket(IbcPacket calldata packet) external override onlyIbcDispatcher {
86 |         timeoutPackets.push(packet);
87 |         // do logic
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/scripts/x-ballot-nft/_app-events-UC.js:
--------------------------------------------------------------------------------
 1 | const hre = require("hardhat");
 2 | const { getConfigPath } = require("../private/_helpers.js");
 3 | const { getIbcApp } = require("../private/_vibc-helpers.js");
 4 | 
 5 | const explorerOpUrl = "https://optimism-sepolia.blockscout.com/";
 6 | const explorerBaseUrl = "https://base-sepolia.blockscout.com/";
 7 | 
 8 | function listenForBallotEvents(network, ballot) {
 9 |     const explorerUrl = network === "optimism" ? explorerOpUrl : explorerBaseUrl;
10 |     console.log(`👂 Listening for Ballot events on ${network}...`);
11 | 
12 |     ballot.on("Voted", (voter, proposal, event) => {
13 |         const txHash = event.log.transactionHash;
14 |         const url = `${explorerUrl}tx/${txHash}`;
15 |         console.log(`
16 |           -------------------------------------------
17 |           🗳️  Voted on Ballot !!!   🗳️
18 |           -------------------------------------------
19 |           🔔 Event name: ${event.log.fragment.name}
20 |           ☎️  Voter address: ${voter}
21 |           📜 Proposal ID: ${proposal}
22 |           -------------------------------------------
23 |           🧾 TxHash: ${txHash}
24 |           🔍 Explorer URL: ${url}
25 |           -------------------------------------------\n`);
26 |     });
27 | 
28 |     ballot.on("SendVoteInfo", (destPortAddr, voter, recipient, proposal, event ) => {
29 |         const txHash = event.log.transactionHash;
30 |         const url = `${explorerUrl}tx/${txHash}`;
31 |         console.log(`
32 |           -------------------------------------------
33 |           📦🗳️  Vote Info Sent !!!   🗳️📦
34 |           -------------------------------------------
35 |           🔔 Event name: ${event.log.fragment.name}
36 |           ☎️  Voter address: ${voter}
37 |           ☎️  Recipient address: ${recipient}
38 |           📜 Proposal ID: ${proposal}
39 |           🔗 Counterparty application: ${destPortAddr}
40 |           -------------------------------------------
41 |           🧾 TxHash: ${txHash}
42 |           🔍 Explorer URL: ${url}
43 |           -------------------------------------------\n`);
44 |     });
45 | 
46 |     ballot.on("AckNFTMint", (destPortAddr, voter, voteNFTid, event ) => {
47 |         const txHash = event.log.transactionHash;
48 |         const url = `${explorerUrl}tx/${txHash}`;
49 |         console.log(`
50 |           -------------------------------------------
51 |           📦🖼️  NFT Minted Ack !!!   🖼️📦
52 |           -------------------------------------------
53 |           🔔 Event name: ${event.log.fragment.name}
54 |           ☎️  Voter address: ${voter}
55 |           🖼️  Proof-Of-Vote NFT ID: ${voteNFTid}
56 |           🔗 Counterparty application: ${destPortAddr}
57 |           -------------------------------------------
58 |           🧾 TxHash: ${txHash}
59 |           🔍 Explorer URL: ${url}
60 |           -------------------------------------------\n`);
61 | 
62 |         ballot.removeAllListeners();
63 |     });    
64 | }
65 | 
66 | async function setupUcXBallotNFTEventListener() {
67 |     console.log("🔊 Setting up Ballot and NFT event listeners...")
68 |     const config = require(getConfigPath());
69 | 
70 |     const srcIbcApp = await getIbcApp("optimism"); // How to get source chain when using universal channels?
71 |     listenForBallotEvents("optimism", srcIbcApp);
72 | }
73 | 
74 | module.exports = { setupUcXBallotNFTEventListener };
75 | 


--------------------------------------------------------------------------------
/scripts/x-ballot-nft/_app-events.js:
--------------------------------------------------------------------------------
 1 | const hre = require("hardhat");
 2 | const { getConfigPath } = require("../private/_helpers.js");
 3 | const { getIbcApp } = require("../private/_vibc-helpers.js");
 4 | 
 5 | const explorerOpUrl = "https://optimism-sepolia.blockscout.com/";
 6 | const explorerBaseUrl = "https://base-sepolia.blockscout.com/";
 7 | 
 8 | function listenForBallotEvents(network, ballot) {
 9 |     const explorerUrl = network === "optimism" ? explorerOpUrl : explorerBaseUrl;
10 |     console.log(`👂 Listening for Ballot events on ${network}...`);
11 | 
12 |     ballot.on("Voted", (voter, proposal, event) => {
13 |         const txHash = event.log.transactionHash;
14 |         const url = `${explorerUrl}tx/${txHash}`;
15 |         console.log(`
16 |           -------------------------------------------
17 |           🗳️  Voted on Ballot !!!   🗳️
18 |           -------------------------------------------
19 |           🔔 Event name: ${event.log.fragment.name}
20 |           ☎️  Voter address: ${voter}
21 |           📜 Proposal ID: ${proposal}
22 |           -------------------------------------------
23 |           🧾 TxHash: ${txHash}
24 |           🔍 Explorer URL: ${url}
25 |           -------------------------------------------\n`);
26 |     });
27 | 
28 |     ballot.on("SendVoteInfo", (channelId, voter, recipient, proposal, event ) => {
29 |         const txHash = event.log.transactionHash;
30 |         const url = `${explorerUrl}tx/${txHash}`;
31 |         const channelIdString = hre.ethers.decodeBytes32String(channelId);
32 |         console.log(`
33 |           -------------------------------------------
34 |           📦🗳️  Vote Info Sent !!!   🗳️📦
35 |           -------------------------------------------
36 |           🔔 Event name: ${event.log.fragment.name}
37 |           ☎️  Voter address: ${voter}
38 |           ☎️  Recipient address: ${recipient}
39 |           📜 Proposal ID: ${proposal}
40 |           🛣️  Source Channel ID: ${channelIdString}
41 |           -------------------------------------------
42 |           🧾 TxHash: ${txHash}
43 |           🔍 Explorer URL: ${url}
44 |           -------------------------------------------\n`);
45 |     });
46 | 
47 |     ballot.on("AckNFTMint", (channelId, sequence, voter, voteNFTid, event ) => {
48 |         const txHash = event.log.transactionHash;
49 |         const url = `${explorerUrl}tx/${txHash}`;
50 |         const channelIdString = hre.ethers.decodeBytes32String(channelId);
51 |         console.log(`
52 |           -------------------------------------------
53 |           📦🖼️  NFT Minted Ack !!!   🖼️📦
54 |           -------------------------------------------
55 |           🔔 Event name: ${event.log.fragment.name}
56 |           ☎️  Voter address: ${voter}
57 |           🖼️  Proof-Of-Vote NFT ID: ${voteNFTid}
58 |           🛣️  Source Channel ID: ${channelIdString}
59 |           📈 IBC packet sequence: ${sequence}
60 |           -------------------------------------------
61 |           🧾 TxHash: ${txHash}
62 |           🔍 Explorer URL: ${url}
63 |           -------------------------------------------\n`);
64 | 
65 |         ballot.removeAllListeners();
66 |     });    
67 | }
68 | 
69 | async function setupXBallotNFTEventListener() {
70 |     console.log("🔊 Setting up Ballot and NFT event listeners...")
71 |     const config = require(getConfigPath());
72 | 
73 |     const srcIbcApp = await getIbcApp(config.createChannel.srcChain);
74 |     listenForBallotEvents(config.createChannel.srcChain, srcIbcApp);
75 | }
76 | 
77 | module.exports = { setupXBallotNFTEventListener };
78 | 


--------------------------------------------------------------------------------
/scripts/private/_create-channel.js:
--------------------------------------------------------------------------------
 1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
 2 | // but useful for running the script in a standalone fashion through `node <script>`.
 3 | //
 4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
 5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
 6 | // global scope, and execute the script.
 7 | const hre = require('hardhat');
 8 | const { getConfigPath, addressToPortId } = require('./_helpers');
 9 | const { getIbcApp } = require('./_vibc-helpers.js');
10 | const ibcConfig = require('../../ibc.json');
11 | 
12 | function createDummyProof() {
13 |   return  {
14 |       proof: [
15 |           {
16 |               path: [
17 |                   {
18 |                       prefix: hre.ethers.toUtf8Bytes("prefixExample1"),
19 |                       suffix: hre.ethers.toUtf8Bytes("suffixExample1"),
20 |                   },
21 |                   // Add more OpIcs23ProofPath objects as needed
22 |               ],
23 |               key: hre.ethers.toUtf8Bytes("keyExample"),
24 |               value: hre.ethers.toUtf8Bytes("valueExample"),
25 |               prefix: hre.ethers.toUtf8Bytes("prefixExample")
26 |           },
27 |           // Add more OpIcs23Proof objects as needed
28 |       ],
29 |       height: 123456, // example block height
30 |   };
31 | }
32 | 
33 | async function main() {
34 |   const config = require(getConfigPath());
35 |   const chanConfig = config.createChannel;
36 |   const networkName = hre.network.name;
37 |   
38 |   // Get the contract type from the config and get the contract
39 |   const ibcApp = await getIbcApp(networkName);
40 |   const connectedChannelsBefore = await ibcApp.getConnectedChannels();
41 | 
42 |   // Prepare the arguments to create the channel
43 |   const connHop1 = ibcConfig[chanConfig.srcChain][`${config.proofsEnabled ? 'op-client' : 'sim-client'}`].canonConnFrom;
44 |   const connHop2 = ibcConfig[chanConfig.dstChain][`${config.proofsEnabled ? 'op-client' : 'sim-client'}`].canonConnTo;
45 |   const srcPortId = addressToPortId(`polyibc.${chanConfig.srcChain}`, chanConfig.srcAddr);
46 |   const dstPortId = addressToPortId(`polyibc.${chanConfig.dstChain}`, chanConfig.dstAddr);
47 | 
48 |   const local = {
49 |     portId: srcPortId,
50 |     channelId: hre.ethers.encodeBytes32String(''),
51 |     version: chanConfig.version,
52 |   };
53 | 
54 |   const cp = {
55 |     portId: dstPortId,
56 |     channelId: hre.ethers.encodeBytes32String(''),
57 |     version: '',
58 |   };
59 | 
60 |   // Create the channel
61 |   // Note: The proofHeight and proof are dummy values and will be dropped in the future
62 |   await ibcApp.createChannel(
63 |     local,
64 |     chanConfig.ordering,
65 |     chanConfig.fees,
66 |     [ connHop1, connHop2 ],
67 |     cp,
68 |     createDummyProof()
69 |   );
70 | 
71 |   if (!config.proofsEnabled) {
72 |     // Wait for the channel handshake to complete
73 |     await new Promise((r) => setTimeout(r, 90000));
74 | 
75 |     // Get the connected channels and print the new channel along with its counterparty
76 |     const connectedChannelsAfter = await ibcApp.getConnectedChannels();
77 | 
78 |     if (connectedChannelsAfter!== undefined && connectedChannelsAfter.length > connectedChannelsBefore.length) {
79 | 
80 |       const newChannelBytes = connectedChannelsAfter[connectedChannelsAfter.length - 1].channelId;
81 |       const newChannel = hre.ethers.decodeBytes32String(newChannelBytes);
82 | 
83 |       const cpChannelBytes = connectedChannelsAfter[connectedChannelsAfter.length - 1].cpChannelId;
84 |       const cpChannel = hre.ethers.decodeBytes32String(cpChannelBytes);
85 |     
86 |       console.log(`✅ Channel created: ${newChannel} with portID ${srcPortId} on network ${networkName}, Counterparty: ${cpChannel} on network ${chanConfig.dstChain}`);
87 |     }
88 |   }
89 | }
90 | 
91 | // We recommend this pattern to be able to use async/await everywhere
92 | // and properly handle errors.
93 | main().catch((error) => {
94 |   console.error(error);
95 |   process.exitCode = 1;
96 | });


--------------------------------------------------------------------------------
/contracts/XCounterUC.sol:
--------------------------------------------------------------------------------
  1 | //SPDX-License-Identifier: UNLICENSED
  2 | 
  3 | pragma solidity ^0.8.9;
  4 | 
  5 | import "./base/UniversalChanIbcApp.sol";
  6 | 
  7 | contract XCounterUC is UniversalChanIbcApp {
  8 |     // application specific state
  9 |     uint64 public counter;
 10 |     mapping(uint64 => address) public counterMap;
 11 | 
 12 |     constructor(address _middleware) UniversalChanIbcApp(_middleware) {}
 13 | 
 14 |     // application specific logic
 15 |     function resetCounter() internal {
 16 |         counter = 0;
 17 |     }
 18 | 
 19 |     function increment() internal {
 20 |         counter++;
 21 |     }
 22 | 
 23 |     // IBC logic
 24 | 
 25 |     /**
 26 |      * @dev Sends a packet with the caller's address over the universal channel.
 27 |      * @param destPortAddr The address of the destination application.
 28 |      * @param channelId The ID of the channel to send the packet to.
 29 |      * @param timeoutSeconds The timeout in seconds (relative).
 30 |      */
 31 |     function sendUniversalPacket(address destPortAddr, bytes32 channelId, uint64 timeoutSeconds) external {
 32 |         increment();
 33 |         bytes memory payload = abi.encode(msg.sender, counter);
 34 | 
 35 |         uint64 timeoutTimestamp = uint64((block.timestamp + timeoutSeconds) * 1000000000);
 36 | 
 37 |         IbcUniversalPacketSender(mw).sendUniversalPacket(
 38 |             channelId, IbcUtils.toBytes32(destPortAddr), payload, timeoutTimestamp
 39 |         );
 40 |     }
 41 | 
 42 |     /**
 43 |      * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
 44 |      *      MUST be overriden by the inheriting contract.
 45 |      *
 46 |      * @param channelId the ID of the channel (locally) the packet was received on.
 47 |      * @param packet the Universal packet encoded by the source and relayed by the relayer.
 48 |      */
 49 |     function onRecvUniversalPacket(bytes32 channelId, UniversalPacket calldata packet)
 50 |         external
 51 |         override
 52 |         onlyIbcMw
 53 |         returns (AckPacket memory ackPacket)
 54 |     {
 55 |         recvedPackets.push(UcPacketWithChannel(channelId, packet));
 56 | 
 57 |         (address payload, uint64 c) = abi.decode(packet.appData, (address, uint64));
 58 |         counterMap[c] = payload;
 59 | 
 60 |         increment();
 61 | 
 62 |         return AckPacket(true, abi.encode(counter));
 63 |     }
 64 | 
 65 |     /**
 66 |      * @dev Packet lifecycle callback that implements packet acknowledgment logic.
 67 |      *      MUST be overriden by the inheriting contract.
 68 |      *
 69 |      * @param channelId the ID of the channel (locally) the ack was received on.
 70 |      * @param packet the Universal packet encoded by the source and relayed by the relayer.
 71 |      * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
 72 |      */
 73 |     function onUniversalAcknowledgement(bytes32 channelId, UniversalPacket memory packet, AckPacket calldata ack)
 74 |         external
 75 |         override
 76 |         onlyIbcMw
 77 |     {
 78 |         ackPackets.push(UcAckWithChannel(channelId, packet, ack));
 79 | 
 80 |         // decode the counter from the ack packet
 81 |         (uint64 _counter) = abi.decode(ack.data, (uint64));
 82 | 
 83 |         if (_counter != counter) {
 84 |             resetCounter();
 85 |         }
 86 |     }
 87 | 
 88 |     /**
 89 |      * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
 90 |      *      MUST be overriden by the inheriting contract.
 91 |      *      NOT SUPPORTED YET
 92 |      *
 93 |      * @param channelId the ID of the channel (locally) the timeout was submitted on.
 94 |      * @param packet the Universal packet encoded by the counterparty and relayed by the relayer
 95 |      */
 96 |     function onTimeoutUniversalPacket(bytes32 channelId, UniversalPacket calldata packet) external override onlyIbcMw {
 97 |         timeoutPackets.push(UcPacketWithChannel(channelId, packet));
 98 |         // do logic
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/contracts/base/UniversalChanIbcApp.sol:
--------------------------------------------------------------------------------
 1 | //SPDX-License-Identifier: UNLICENSED
 2 | 
 3 | pragma solidity ^0.8.9;
 4 | 
 5 | import '@open-ibc/vibc-core-smart-contracts/contracts/libs/Ibc.sol';
 6 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcReceiver.sol';
 7 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcDispatcher.sol';
 8 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcMiddleware.sol';
 9 | 
10 | // UniversalChanIbcApp is a contract that can be used as a base contract 
11 | // for IBC-enabled contracts that send packets over the universal channel.
12 | contract UniversalChanIbcApp is IbcMwUser, IbcUniversalPacketReceiver {
13 |     struct UcPacketWithChannel {
14 |         bytes32 channelId;
15 |         UniversalPacket packet;
16 |     }
17 | 
18 |     struct UcAckWithChannel {
19 |         bytes32 channelId;
20 |         UniversalPacket packet;
21 |         AckPacket ack;
22 |     }
23 | 
24 |     // received packet as chain B
25 |     UcPacketWithChannel[] public recvedPackets;
26 |     // received ack packet as chain A
27 |     UcAckWithChannel[] public ackPackets;
28 |     // received timeout packet as chain A
29 |     UcPacketWithChannel[] public timeoutPackets;
30 | 
31 |     constructor(address _middleware) IbcMwUser(_middleware) {}
32 | 
33 |     /** 
34 |      * @dev Implement a function to send a packet that calls the IbcUniversalPacketSender(mw).sendUniversalPacket function
35 |      *      It has the following function handle:
36 |      *          function sendUniversalPacket(
37 |                     bytes32 channelId,
38 |                     bytes32 destPortAddr,
39 |                     bytes calldata appData,
40 |                     uint64 timeoutTimestamp
41 |                 ) external;
42 |      */
43 | 
44 |     /**
45 |      * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
46 |      *      MUST be overriden by the inheriting contract.
47 |      * 
48 |      * @param channelId the ID of the channel (locally) the packet was received on.
49 |      * @param packet the Universal packet encoded by the source and relayed by the relayer.
50 |      */
51 |     function onRecvUniversalPacket(
52 |         bytes32 channelId,
53 |         UniversalPacket calldata packet
54 |     ) external virtual onlyIbcMw returns (AckPacket memory ackPacket) {
55 |         recvedPackets.push(UcPacketWithChannel(channelId, packet));
56 |         // 1. decode the packet.data
57 |         // 2. do logic
58 |         // 3. encode the ack packet (encoding format should be agreed between the two applications)
59 |         // below is an example, the actual ackpacket data should be implemented by the contract developer
60 |         return AckPacket(true, abi.encodePacked(address(this), IbcUtils.toAddress(packet.srcPortAddr), 'ack-', packet.appData));
61 |     }
62 | 
63 |     /**
64 |      * @dev Packet lifecycle callback that implements packet acknowledgment logic.
65 |      *      MUST be overriden by the inheriting contract.
66 |      * 
67 |      * @param channelId the ID of the channel (locally) the ack was received on.
68 |      * @param packet the Universal packet encoded by the source and relayed by the relayer.
69 |      * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
70 |      */
71 |     function onUniversalAcknowledgement(
72 |         bytes32 channelId,
73 |         UniversalPacket memory packet,
74 |         AckPacket calldata ack
75 |     ) external virtual onlyIbcMw {
76 |         ackPackets.push(UcAckWithChannel(channelId, packet, ack));
77 |         // 1. decode the ack.data
78 |         // 2. do logic
79 |     }
80 | 
81 |     /**
82 |      * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
83 |      *      MUST be overriden by the inheriting contract.
84 |      *      NOT SUPPORTED YET
85 |      * 
86 |      * @param channelId the ID of the channel (locally) the timeout was submitted on.
87 |      * @param packet the Universal packet encoded by the counterparty and relayed by the relayer
88 |      */
89 |     function onTimeoutUniversalPacket(bytes32 channelId, UniversalPacket calldata packet) external virtual onlyIbcMw {
90 |         timeoutPackets.push(UcPacketWithChannel(channelId, packet));
91 |         // do logic
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/scripts/private/_switch-clients.js:
--------------------------------------------------------------------------------
 1 | const fs = require('fs');
 2 | const { getConfigPath } = require('./_helpers.js');
 3 | const ibcConfig = require('../../ibc.json');
 4 | 
 5 | // Function to update config.json
 6 | function flipConfig() {
 7 |     try {
 8 |         const configPath = getConfigPath();
 9 |         const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
10 |         // Create a temporary copy of the config object to store a backup of the current values
11 |         // The backup is used when switching back to between clients
12 |         const tempConfig = {...config};
13 |         const source = tempConfig["createChannel"]["srcChain"];
14 |         const destination = tempConfig["createChannel"]["dstChain"];
15 |     
16 |         // Below, we'll update the config object
17 |         if (config.backup !== undefined && typeof config.backup === 'object' && Object.keys(config.backup).length > 0) {
18 |             // Update the createChannel object with backup values 
19 |             config["createChannel"]["srcAddr"] = config["backup"]["sendPacket"][`${source}`]["portAddr"];
20 |             config["createChannel"]["dstAddr"] = config["backup"]["sendPacket"][`${destination}`]["portAddr"];
21 | 
22 |             // Update the sendPacket and sendUniversalPacket object with backup values
23 |             config["sendPacket"] = config["backup"]["sendPacket"];
24 |             config["sendUniversalPacket"] = config["backup"]["sendUniversalPacket"];
25 |         } else {
26 |             // If no backup object is provided, use the default values
27 |             config["createChannel"] = {
28 |                 "srcChain": source,
29 |                 "srcAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
30 |                 "dstChain": destination,
31 |                 "dstAddr": "0x1234567890AbCdEf1234567890aBcDeF12345678",
32 |                 "version": "1.0",
33 |                 "ordering": 0,
34 |                 "fees": false
35 |               };
36 |               config["sendPacket"] = {
37 |                 "optimism": {
38 |                     "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
39 |                     "channelId": "channel-n",
40 |                     "timeout": 36000
41 |                   },
42 |                   "base": {
43 |                     "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
44 |                     "channelId": "channel-n",
45 |                     "timeout": 36000
46 |                   }
47 |                 };
48 |                 config["sendUniversalPacket"] = {
49 |                     "optimism": {
50 |                         "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
51 |                         "channelId": "channel-x",
52 |                         "timeout": 36000
53 |                       },
54 |                       "base": {
55 |                         "portAddr": "0x1234567890abcdef1234567890abcdef12345678",
56 |                         "channelId": "channel-y",
57 |                         "timeout": 36000
58 |                       }
59 |                     };
60 |         }
61 | 
62 |         // Update the universal channel values for new client
63 |         config["sendUniversalPacket"]["optimism"]["channelId"] = 
64 |             tempConfig.proofsEnabled ?
65 |             ibcConfig["optimism"]["sim-client"]["universalChannel"] :
66 |             ibcConfig["optimism"]["op-client"]["universalChannel"];
67 |         config["sendUniversalPacket"]["base"]["channelId"] =
68 |             tempConfig.proofsEnabled ?
69 |             ibcConfig["base"]["sim-client"]["universalChannel"] :
70 |             ibcConfig["base"]["op-client"]["universalChannel"];
71 |         
72 |         // Write a new backup object to the config
73 |         config["backup"] = {
74 |             "sendPacket": tempConfig["sendPacket"],
75 |             "sendUniversalPacket": tempConfig["sendUniversalPacket"]
76 |         };
77 | 
78 |         // Flip the proofsEnabled flag
79 |         config["proofsEnabled"] = !config["proofsEnabled"];
80 | 
81 |         // Write the updated config back to the file
82 |         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
83 |         console.log('🆗 Config updated');
84 |     } catch (error) {
85 |         console.error(`❌ Failed to update config: ${error.message}`);
86 |         process.exit(1);
87 |     }
88 | }
89 | 
90 | flipConfig();
91 | 


--------------------------------------------------------------------------------
/scripts/private/_helpers.js:
--------------------------------------------------------------------------------
  1 | const fs = require('fs');
  2 | const axios = require('axios');
  3 | const hre = require('hardhat');
  4 | const ibcConfig = require("../../ibc.json");
  5 | 
  6 | // Function to get the path to the configuration file
  7 | function getConfigPath() {
  8 |   const path = require('path');
  9 |   const configRelativePath = process.env.CONFIG_PATH ? process.env.CONFIG_PATH : 'config.json';
 10 |   // console.log(`📔 Using config file at ${configRelativePath}`);
 11 |   const configPath = path.join(__dirname, '../..' , configRelativePath);
 12 |   return configPath;
 13 | }
 14 | 
 15 | // Function to update config.json
 16 | function updateConfigDeploy(network, address, isSource) {
 17 |   try {
 18 |     const configPath = getConfigPath();
 19 |     const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
 20 |     // Update the config object
 21 |     if (!config.isUniversal) {
 22 |       if (isSource) {
 23 |         config["createChannel"]["srcChain"] = network;
 24 |         config["createChannel"]["srcAddr"] = address;
 25 |       } else {
 26 |         config["createChannel"]["dstChain"] = network;
 27 |         config["createChannel"]["dstAddr"] = address;
 28 |       }
 29 |   
 30 |       config["sendPacket"][`${network}`]["portAddr"] = address;    
 31 |     } else if (config.isUniversal){
 32 |       // When using the universal channel, we can skip channel creation and instead update the sendUniversalPacket field in the config
 33 |       const client = config.proofsEnabled ? 'op-client' : 'sim-client';
 34 |       config["sendUniversalPacket"][`${network}`]["portAddr"] = address;
 35 |       config["sendUniversalPacket"][`${network}`]["channelId"] = ibcConfig[`${network}`][`${client}`]["universalChannel"];
 36 |     }
 37 |   
 38 |     // Write the updated config back to the file
 39 |     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 40 |   } catch (error) {
 41 |     console.error('❌ Error updating config:', error);
 42 |   }
 43 | }
 44 | 
 45 | // Function to update config.json
 46 | function updateConfigCreateChannel(network, channel, cpNetwork, cpChannel) {
 47 |   try {
 48 |     const configPath = getConfigPath();
 49 |     const upConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
 50 |   
 51 |     // Update the config object
 52 |     upConfig["sendPacket"][`${network}`]["channelId"] = channel;
 53 |     upConfig["sendPacket"][`${cpNetwork}`]["channelId"] = cpChannel;
 54 |   
 55 |     // Write the updated config back to the file
 56 |     fs.writeFileSync(configPath, JSON.stringify(upConfig, null, 2));
 57 |   } catch (error) {
 58 |     console.error('❌ Error updating config:', error);
 59 |   }
 60 | }
 61 | 
 62 | async function fetchABI(explorerUrl, contractAddress) {
 63 |   try {
 64 |     const response = await axios.get(`${explorerUrl}api/v2/smart-contracts/${contractAddress}`);
 65 |     if (response.status === 200) {
 66 |       const abi = response.data.abi;
 67 |       return abi;
 68 |     } else {
 69 |       console.error(`❌ Failed to fetch ABI, status code: ${response.status}`);
 70 |       return null;
 71 |     }
 72 |   } catch (error) {
 73 |     console.error('❌ Error fetching ABI:', error);
 74 |     return null;
 75 |   }
 76 | }
 77 | 
 78 | function areAddressesEqual(address1, address2) {
 79 |   // Validate input addresses
 80 |   if (!hre.ethers.isAddress(address1) || !hre.ethers.isAddress(address2)) {
 81 |     throw new Error('❌ One or both addresses are not valid Ethereum addresses');
 82 |   }
 83 |   // Normalize addresses to checksummed format
 84 | 
 85 |   const checksumAddress1 = hre.ethers.getAddress(address1);
 86 |   const checksumAddress2 = hre.ethers.getAddress(address2);
 87 | 
 88 |   // Compare addresses
 89 |   const areEqual = checksumAddress1 === checksumAddress2;
 90 |   return areEqual;
 91 | }
 92 | 
 93 | // Helper function to convert an address to a port ID
 94 | function addressToPortId(portPrefix, address) {
 95 |   const config = require(getConfigPath());
 96 |   const simAddOn = config.proofsEnabled ? '-proofs-1' :'-sim';
 97 |   const suffix = address.slice(2);
 98 |   return `${portPrefix}${simAddOn}.${suffix}`;
 99 | }
100 | 
101 | function getWhitelistedNetworks() {
102 |   return Object.keys(ibcConfig);
103 | }
104 | 
105 | module.exports = { 
106 |   getConfigPath,
107 |   updateConfigDeploy,
108 |   updateConfigCreateChannel,
109 |   fetchABI,
110 |   areAddressesEqual,
111 |   addressToPortId,
112 |   getWhitelistedNetworks
113 | };
114 | 


--------------------------------------------------------------------------------
/Justfile:
--------------------------------------------------------------------------------
  1 | # Install dependencies
  2 | install:
  3 |     echo "Installing dependencies"
  4 |     npm install
  5 |     forge install --shallow
  6 | 
  7 | # Compile contracts using the specified compiler or default to Hardhat
  8 | # The compiler argument is optional; if not provided, it defaults to "hardhat".
  9 | # Usage: just compile [compiler]
 10 | compile COMPILER='hardhat':
 11 |     #!/usr/bin/env sh
 12 |     if test "{{COMPILER}}" = "hardhat"; then
 13 |         echo "Compiling contracts with Hardhat..."
 14 |         npx hardhat compile
 15 |     elif test "{{COMPILER}}" = "foundry"; then
 16 |         echo "Compiling contracts with Foundry..."
 17 |         forge build
 18 |     else
 19 |         echo "Unknown compiler: {{COMPILER}}"
 20 |         exit 1
 21 |     fi
 22 | 
 23 | # Update the config.json file with the contract type for a specified chain/rollup
 24 | # The chain and contract-type arguments are REQUIRED;
 25 | # The universal argument is optional; if not provided, it defaults to "true".
 26 | # It indicates whether the contracts to deploy are using custom or universal IBC channels to send packets.
 27 | # Usage: just set-contracts [chain] [contract-type] [universal]
 28 | set-contracts CHAIN CONTRACT_TYPE UNIVERSAL='true':
 29 |     echo "Updating config.json with contract type..."
 30 |     node scripts/private/_set-contracts-config.js {{CHAIN}} {{CONTRACT_TYPE}} {{UNIVERSAL}}
 31 | 
 32 | # Deploy the contracts in the /contracts folder using Hardhat and updating the config.json file
 33 | # The source and destination arguments are REQUIRED;
 34 | # Usage: just deploy [source] [destination]
 35 | deploy SOURCE DESTINATION:
 36 |         echo "Deploying contracts with Hardhat..."
 37 |         node scripts/private/_deploy-config.js {{SOURCE}} {{DESTINATION}}
 38 | 
 39 | # Run the sanity check script to verify that configuration (.env) files match with deployed contracts' stored values
 40 | # Usage: just sanity-check
 41 | sanity-check:
 42 |     echo "Running sanity check..."
 43 |     node scripts/private/_sanity-check.js
 44 | 
 45 | # Update the dispatcher or universal channel handler address on the IBC application, with that from the .env file
 46 | # The chain argument is REQUIRED;
 47 | # Usage: just update-vibc [chain]
 48 | update-vibc CHAIN:
 49 |   echo "Updating the dispatcher or universal channel handler address..."
 50 |   npx hardhat run scripts/private/_update-vibc-address.js --network {{CHAIN}}
 51 | 
 52 | # Create a channel by triggering a channel handshake from the source and with parameters found in the config.json file
 53 | # Usage: just create-channel
 54 | create-channel:
 55 |     echo "Attempting to create a channel with the values from the config..."
 56 |     node scripts/private/_create-channel-config.js
 57 | 
 58 | # Send a packet over the universal channel or a custom channel as defined in the config.json file
 59 | # The source argument is REQUIRED;
 60 | # Usage: just send-packet [source]
 61 | send-packet SOURCE:
 62 |     echo "Sending a packet with the values from the config..."
 63 |     node scripts/private/_send-packet-config.js {{SOURCE}}
 64 | 
 65 | # Send a packet over the universal channel or a custom channel as defined in the config.json file
 66 | # The source argument is REQUIRED;
 67 | # Usage: just send-packet [source]
 68 | send-vote-info:
 69 |     echo "Sending an IBC packet with vote information to mint a Proof-of-Vote NFT..."
 70 |     node scripts/private/_send-vote-info-config.js
 71 | 
 72 | # Switch between the sim client and the client with proofs
 73 | # Usage: just switch-client
 74 | switch-client:
 75 |     echo "Switching between sim client and client with proofs..."
 76 |     npx hardhat run scripts/private/_update-vibc-address.js --network optimism
 77 |     npx hardhat run scripts/private/_update-vibc-address.js --network base
 78 |     node scripts/private/_switch-clients.js
 79 | 
 80 | # Run the full E2E flow by setting the contracts, deploying them, creating a channel, and sending a packet
 81 | # Usage: just do-it
 82 | do-it:
 83 |     echo "Running the full E2E flow..."
 84 |     just set-contracts optimism XCounter false && just set-contracts base XCounter false
 85 |     just deploy optimism base
 86 |     just sanity-check
 87 |     just create-channel
 88 |     just send-packet optimism
 89 |     echo "You've done it!"
 90 | 
 91 | # Clean up the environment by removing the artifacts and cache folders and running the forge clean command
 92 | # Usage: just clean
 93 | clean:
 94 |     echo "Cleaning up environment..."
 95 |     rm -rf artifacts cache
 96 |     forge clean
 97 | 
 98 | # Fully clean the environment by removing the artifacts, the dependencies, and cache folders and running the forge clean-all command
 99 | # Usage: just clean-all
100 | clean-all:
101 |     echo "Cleaning up environment..."
102 |     rm -rf artifacts cache
103 |     forge clean
104 |     rm -rf node_modules
105 | 


--------------------------------------------------------------------------------
/scripts/private/_vibc-helpers.js:
--------------------------------------------------------------------------------
  1 | const {ethers} = require("hardhat");
  2 | const { getConfigPath, fetchABI} = require("./_helpers.js");
  3 | 
  4 | const explorerOpUrl = "https://optimism-sepolia.blockscout.com/";
  5 | const explorerBaseUrl = "https://base-sepolia.blockscout.com/";
  6 | 
  7 | const rpcOptimism = `https://opt-sepolia.g.alchemy.com/v2/${process.env.OP_ALCHEMY_API_KEY}`;
  8 | const rpcBase = `https://base-sepolia.g.alchemy.com/v2/${process.env.BASE_ALCHEMY_API_KEY}`;
  9 | 
 10 | async function getIbcApp (network) {
 11 |     try {
 12 |         const config = require(getConfigPath());
 13 |         const ibcAppAddr = config.isUniversal ? config["sendUniversalPacket"][`${network}`]["portAddr"] : config["sendPacket"][`${network}`]["portAddr"];
 14 |         console.log(`🗄️  Fetching IBC app on ${network} at address: ${ibcAppAddr}`)
 15 |         const contractType = config["deploy"][`${network}`];
 16 |         const ibcApp = await ethers.getContractAt(
 17 |             `${contractType}`,
 18 |             ibcAppAddr
 19 |         );
 20 |         return ibcApp;
 21 |     } catch (error) {
 22 |         console.log(`❌ Error getting IBC app: ${error}`);
 23 |         return;
 24 |     }
 25 |   }
 26 | 
 27 | function getDispatcherAddress(network) {
 28 |     const config = require(getConfigPath());
 29 |     let dispatcherAddr;
 30 |     if (network === "optimism") {
 31 |         dispatcherAddr = config.proofsEnabled ? process.env.OP_DISPATCHER : process.env.OP_DISPATCHER_SIM;
 32 |     } else if (network === "base") {
 33 |         dispatcherAddr = config.proofsEnabled ? process.env.BASE_DISPATCHER : process.env.BASE_DISPATCHER_SIM;
 34 |     } else {
 35 |         throw new Error("❌ Invalid network");
 36 |     }
 37 |     return dispatcherAddr;
 38 | }
 39 | 
 40 | async function getDispatcher (network) {
 41 |     const config = require(getConfigPath());
 42 |     const providerOptimism = new ethers.JsonRpcProvider(rpcOptimism);
 43 |     const providerBase = new ethers.JsonRpcProvider(rpcBase);
 44 | 
 45 |     let explorerUrl;
 46 |     let dispatcher;
 47 |     let dispatcherAddress;
 48 |     try {
 49 |         if (network === "optimism") {
 50 |             explorerUrl = explorerOpUrl;
 51 |             dispatcherAddress = config.proofsEnabled ? dispatcherAddress = process.env.OP_DISPATCHER : dispatcherAddress = process.env.OP_DISPATCHER_SIM;
 52 | 
 53 |             const opDispatcherAbi = await fetchABI(explorerUrl, dispatcherAddress);
 54 |             dispatcher = new ethers.Contract(dispatcherAddress, opDispatcherAbi, providerOptimism);
 55 |         } else if (network === "base") {
 56 |             explorerUrl = explorerBaseUrl;
 57 |             dispatcherAddress = config.proofsEnabled ? dispatcherAddress = process.env.BASE_DISPATCHER : dispatcherAddress = process.env.BASE_DISPATCHER_SIM;
 58 | 
 59 |             const baseDispatcherAbi = await fetchABI(explorerUrl, dispatcherAddress);
 60 |             dispatcher = new ethers.Contract(dispatcherAddress, baseDispatcherAbi, providerBase);
 61 |         } else {
 62 |             throw new Error(`❌ Invalid network: ${network}`);
 63 |         }
 64 |         return dispatcher;
 65 |     }
 66 |     catch (error) {
 67 |         console.log(`❌ Error getting dispatcher: ${error}`);
 68 |         return;
 69 |     }
 70 | }
 71 | 
 72 | function getUcHandlerAddress(network) {
 73 |     const config = require(getConfigPath());
 74 |     let ucHandlerAddr;
 75 |     if (network === "optimism") {
 76 |         ucHandlerAddr = config.proofsEnabled ? process.env.OP_UC_MW : process.env.OP_UC_MW_SIM;
 77 |     } else if (network === "base") {
 78 |         ucHandlerAddr = config.proofsEnabled ? process.env.BASE_UC_MW : process.env.BASE_UC_MW_SIM;
 79 |     } else {
 80 |         throw new Error("❌ Invalid network");
 81 |     }
 82 |     return ucHandlerAddr;
 83 | }
 84 | 
 85 | async function getUcHandler (network) {
 86 |     const config = require(getConfigPath());
 87 |     const providerOptimism = new ethers.JsonRpcProvider(rpcOptimism);
 88 |     const providerBase = new ethers.JsonRpcProvider(rpcBase);
 89 | 
 90 |     let explorerUrl;
 91 |     let ucHandler;
 92 |     let ucHandlerAddress;
 93 | 
 94 |     try {
 95 |         if (network === "optimism") {
 96 |             explorerUrl = explorerOpUrl;
 97 |             ucHandlerAddress = config.proofsEnabled ? process.env.OP_UC_MW : process.env.OP_UC_MW_SIM;
 98 | 
 99 |             const opUcHandlerAbi = await fetchABI(explorerUrl, ucHandlerAddress);
100 |             ucHandler = new ethers.Contract(ucHandlerAddress, opUcHandlerAbi, providerOptimism);
101 |         } else if (network === "base") {
102 |             explorerUrl = explorerBaseUrl;
103 |             ucHandlerAddress = config.proofsEnabled ? process.env.BASE_UC_MW : process.env.BASE_UC_MW_SIM;
104 | 
105 |             const baseUcHandlerAbi = await fetchABI(explorerUrl, ucHandlerAddress);
106 |             ucHandler = new ethers.Contract(ucHandlerAddress, baseUcHandlerAbi, providerBase);
107 |         } else {
108 |             throw new Error(`❌ Invalid network: ${network}`);
109 |         }
110 | 
111 |         return ucHandler;
112 |     } catch (error) {
113 |         console.log(`❌ Error getting ucHandler: ${error}`);
114 |         return;
115 |     }
116 | }
117 | 
118 | module.exports = { getIbcApp, getDispatcherAddress, getDispatcher, getUcHandlerAddress, getUcHandler };


--------------------------------------------------------------------------------
/scripts/private/_sanity-check-universal.js:
--------------------------------------------------------------------------------
  1 | // We require the Hardhat Runtime Environment explicitly here. This is optional
  2 | // but useful for running the script in a standalone fashion through `node <script>`.
  3 | //
  4 | // You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
  5 | // will compile your contracts, add the Hardhat Runtime Environment's members to the
  6 | // global scope, and execute the script.
  7 | const hre = require("hardhat");
  8 | const { getConfigPath, areAddressesEqual } = require('./_helpers.js');
  9 | const { getIbcApp, getUcHandler } = require("./_vibc-helpers.js");
 10 | 
 11 | async function main() {
 12 |     const config = require(getConfigPath());
 13 |     const accounts = await hre.ethers.getSigners();
 14 |     const networkName = hre.network.name;
 15 | 
 16 |     // Get the Universal Channel Mw from your IBC enabled contract and comare it with the values in the .env file
 17 | 
 18 |     // 1. Get the contract type from the config and get the contract
 19 |     const ibcApp = await getIbcApp(networkName);
 20 | 
 21 |     // 2. Query your app for the Universal Channel Mw address stored
 22 |     let ucHandlerAddr;
 23 |     try {
 24 |         ucHandlerAddr = await ibcApp.mw();
 25 |     } catch (error) {
 26 |         console.log(`❌ Error getting Universal Channel Mw address from IBC app. Check if the configuration file has the correct isUniversal flag set...`);
 27 |         return;
 28 |     }
 29 | 
 30 |     // 3. Compare with the value expected in the .env config file
 31 |     let sanityCheck = false;
 32 |     let envUcHandlerAddr;
 33 |     try {
 34 |         if (networkName === "optimism") {
 35 |             envUcHandlerAddr = config.proofsEnabled === true ? process.env.OP_UC_MW : process.env.OP_UC_MW_SIM;
 36 |             sanityCheck = areAddressesEqual(ucHandlerAddr, envUcHandlerAddr);
 37 |         } else if (networkName === "base") {
 38 |             envUcHandlerAddr = config.proofsEnabled === true ? process.env.BASE_UC_MW : process.env.BASE_UC_MW_SIM;
 39 |             sanityCheck = areAddressesEqual(ucHandlerAddr, envUcHandlerAddr);
 40 |         }
 41 |     } catch (error) {
 42 |         console.log(`❌ Error comparing Universal Channel Mw addresses in .env file and IBC app: ${error}`);
 43 |         return;
 44 |     }
 45 | 
 46 |     // 4. If true, we continue to check the dispatcher stored in the Universal Channel Mw
 47 |     let envDispatcherAddr;
 48 |     let dispatcherAddr;
 49 |     let ucHandler;
 50 |     
 51 |     if (sanityCheck) {
 52 |         try {
 53 |             ucHandler = await getUcHandler(networkName);
 54 |             dispatcherAddr = await ucHandler.dispatcher();
 55 |             if (networkName === "optimism") {
 56 |                 envDispatcherAddr = config.proofsEnabled === true ? process.env.OP_DISPATCHER : process.env.OP_DISPATCHER_SIM;
 57 |                 sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
 58 |             } else if (networkName === "base") {
 59 |                 envDispatcherAddr = config.proofsEnabled === true ? process.env.BASE_DISPATCHER : process.env.BASE_DISPATCHER_SIM;
 60 |                 sanityCheck = areAddressesEqual(dispatcherAddr, envDispatcherAddr);
 61 |             } else {
 62 |                 sanityCheck = false;
 63 |             }
 64 |         } catch (error) {
 65 |             console.log(`❌ Error getting dispatcher address from Universal Channel Mw or from config: ${error}`);
 66 |             return;
 67 |         }
 68 |     } else {
 69 |         console.log(`
 70 | ⛔ Sanity check failed for network ${networkName}, 
 71 | check if the values provided in the .env file for the Universal Channel Mw and the dispatcher are correct.
 72 | --------------------------------------------------
 73 | 🔮 Expected Universal Channel Handler (in IBC contract): ${ucHandlerAddr}...
 74 | 🗃️  Found Universal Channel Handler (in .env file): ${envUcHandlerAddr}...
 75 | --------------------------------------------------
 76 |         `);
 77 |         return;
 78 |     }
 79 | 
 80 |     if (sanityCheck) {
 81 |         const channelBytes = await ucHandler.connectedChannels(0);
 82 |         const channelId = hre.ethers.decodeBytes32String(channelBytes);
 83 |         const envChannelId = config["sendUniversalPacket"][networkName]["channelId"];
 84 | 
 85 |         if (channelId !== envChannelId) {
 86 |             sanityCheck = false;
 87 |             console.log(`
 88 | ⛔ Sanity check failed for network ${networkName}, 
 89 | check if the channel id value for the Universal channel in the config is correct.
 90 | --------------------------------------------------
 91 | 🔮 Expected Channel ID (in Universal Channel Handler contract): ${channelId}...
 92 | 🗃️  Found Dispatcher (in .env file): ${envChannelId}...
 93 | --------------------------------------------------
 94 | `);
 95 |             return;
 96 |         }
 97 |     }
 98 | 
 99 |     // 5. Print the result of the sanity check
100 |     // If true, it means all values in the contracts check out with those in the .env file and we can continue with the script.
101 |     if (sanityCheck) {
102 |         console.log(`✅ Sanity check passed for network ${networkName}`);
103 |     } else {    
104 |         console.log(`
105 | ⛔ Sanity check failed for network ${networkName}, 
106 | check if the values provided in the .env file for the Universal Channel Mw and the dispatcher are correct.
107 | --------------------------------------------------
108 | 🔮 Expected Dispatcher (in Universal Channel Handler contract): ${dispatcherAddr}...
109 | 🗃️  Found Dispatcher (in .env file): ${envDispatcherAddr}...
110 | --------------------------------------------------
111 | `);
112 |     }
113 | }
114 | 
115 | // We recommend this pattern to be able to use async/await everywhere
116 | // and properly handle errors.
117 | main().catch((error) => {
118 |     console.error(error);
119 |     process.exitCode = 1;
120 |   });


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Demo dApps for Polymer
  2 | 
  3 | Welcome to the official repository for [Polymer](https://polymerlabs.org) demo applications! This repository serves as a centralized hub for the official (maintained by the Polymer Labs team and used in the official docs) demo apps, showcasing the capabilities and use cases of Polymer x [IBC](https://ibcprotocol.dev) interoperability.
  4 | 
  5 | ### 🦸🏼🦸🏾‍♂️ Community projects 🦸🏾‍♀️🦸🏻
  6 | 
  7 | We highly encourage our community to build new demos and showcase them! To help visibility of these projects, they can be added to the [community demo dApps repo](https://github.com/polymerdevs/community-demo-dapps) in the PolymerDevs GitHub org.
  8 | 
  9 | ## 📚 Documentation
 10 | 
 11 | This repository is forked from [the IBC app template repo](https://open-ibc/ibc-app-solidity-template) so check it out if you haven't or find its docs [here](ibc-app-template.md).
 12 | 
 13 | There's some basic information here in the README but all of the dApps found here are documented more extensively in [the official Polymer documentation](https://docs.polymerlabs.org/docs/quickstart/start).
 14 | 
 15 | ## 📋 Prerequisites
 16 | 
 17 | The demo dapps repository has been based off of the project structure found in the [IBC app template for Solidity](https://github.com/open-ibc/ibc-app-solidity-template) so it has the same requirements:
 18 | 
 19 | - Have [git](https://git-scm.com/downloads) installed
 20 | - Have [node](https://nodejs.org) installed (v18+)
 21 | - Have [Foundry](https://book.getfoundry.sh/getting-started/installation) installed (Hardhat will be installed when running `npm install`)
 22 | - Have [just](https://just.systems/man/en/chapter_1.html) installed (recommended but not strictly necessary)
 23 | 
 24 | Some basic knowledge of all of these tools is also required, although the details are abstracted away for basic usage.
 25 | 
 26 | ## 🧱 Repository Structure
 27 | 
 28 | This repository has a project structure that set it up to be compatible with the Hardhat and Foundry EVM development environments, as in the [IBC app template for Solidity repo](https://github.com/open-ibc/ibc-app-solidity-template). 
 29 | 
 30 | The main logic specific to the dApps can be found in the `/contracts` directory:
 31 | ```bash
 32 | # Example tree structure with only one custom dApp, x-ballot-nft
 33 | contracts
 34 | ├── XCounter.sol
 35 | ├── XCounterUC.sol
 36 | ├── base
 37 | │   ├── CustomChanIbcApp.sol
 38 | │   ├── GeneralMiddleware.sol
 39 | │   └── UniversalChanIbcApp.sol
 40 | ├── x-ballot-nft
 41 | │   ├── XBallot.sol
 42 | │   └── XProofOfVoteNFT.sol
 43 | └── x-ballot-nft-UC
 44 |     ├── XBallotUC.sol
 45 |     └── XProofOfVoteNFTUC.sol
 46 | ```
 47 | 
 48 | The `/contracts` directory always contains a `/base` directory where custom developed contract will inherit from to quickly get IBC compatibility. Additionally, you'll find the x-counter example from the IBC app template repo.
 49 | 
 50 | The additional folders are the custom developed applications.
 51 | 
 52 | ## 🦮 Dependency management
 53 | 
 54 | This repo depends on Polymer's [vibc-core-smart-contracts](https://github.com/open-ibc/vibc-core-smart-contracts) which are tracked as git submodules. 
 55 | 
 56 | There are two ways to install these dependencies.
 57 | 
 58 | ### Using IBC app template just recipe
 59 | 
 60 | If you have Node and Foundry installed, simply run:
 61 | ```bash
 62 | just install
 63 | ```
 64 | 
 65 | To install the required dependencies.
 66 | 
 67 | ### Using git submodules directly
 68 | 
 69 | If you prefer not to use Foundry / Forge, you can use git submodules directly.
 70 | 
 71 | After cloning the repo, run this command additionally:
 72 | ```bash
 73 | git submodule update --init --recursive
 74 | ```
 75 | 
 76 | Find more documentation on using git submodules from the [official docs](https://git-scm.com/book/en/v2/Git-Tools-Submodules) or [in this tutorial](https://www.atlassian.com/git/tutorials/git-submodule).
 77 | 
 78 | Also run `npm install` additionally.
 79 | 
 80 | ## 💻 Interacting with demos
 81 | 
 82 | To interact with any of the demos, there's a couple of things to do. (Assuming the dependencies have been installed).
 83 | 
 84 | 1. Convert the `.env.example` file into an `.env` file. This will ignore the file for future git commits as well as expose the environment variables. Add your private keys and update the other values if you want to customize (advanced usage feature).
 85 | 
 86 | 2. Check out the configuration file; `config.json` or the alternate configs in the `/config` directory. Depending on which application you'll want to interact with, update the contract type in the `deploy` field to the desired contract (use the `just set-contracts` recipe for that). For example, when interacting with x-ballot-nft-UC you would put 'XBallotUC' and 'XProofOfVoteNFTUC' for optimism or base (which one you pick where does not matter).
 87 | 
 88 | 3. Once the configuration file is updated and saved, you can look at the `just` commands with `just --list`. Alternatively follow the instructions in [the official Polymer documentation](https://docs.polymerlabs.org/docs/quickstart/start).
 89 | 
 90 | ## 🤝 Contributing
 91 | 
 92 | We welcome and encourage contributions from our community! Here’s how you can contribute.
 93 | 
 94 | ### Option 1: Improve IBC Solidity app template
 95 | 
 96 | Have ideas how to improve the project environment itself, not just application logic? Feel free to drop an issue or a PR (after forking) in the [IBC app template for Solidity](https://github.com/open-ibc/ibc-app-solidity-template) repository.
 97 | 
 98 | ### Option 2: Contribute to Polymer official demo-dapps
 99 | 
100 | Have you seen an issue with any of the demo apps listed in this repo? Feel free to drop an issue or implement the changes yourself. Also if you feel you have a great addition that could live in the official docs, drop a PR and we'll investigate (it's possible we'll ask you to add it to the [community demo dApps repo](https://github.com/polymerdevs/community-demo-dapps) instead).
101 | 
102 | Please follow these steps when you do submit code changes:
103 | 
104 | 1. **Fork the Repository:** Start by forking this repository.
105 | 2. **Add Your Demo App or make changes:** Place your demo app in the `/contracts` directory (separate directory for your project) or update the code that can be improved.
106 | 3. **Create a Pull Request:** Once you've added your demo or updated the code, create a pull request to the main repository with a detailed description of your app.
107 | 
108 | ## 💡 Questions or Suggestions?
109 | 
110 | Feel free to open an issue for questions, suggestions, or discussions related to this repository. For further discussion as well as a showcase of some community projects, check out the [Polymer developer forum](https://forum.polymerlabs.org).
111 | 
112 | Thank you for being a part of our community!
113 | 
114 | 


--------------------------------------------------------------------------------
/contracts/base/GeneralMiddleware.sol:
--------------------------------------------------------------------------------
  1 | //SPDX-License-Identifier: UNLICENSED
  2 | 
  3 | pragma solidity ^0.8.9;
  4 | 
  5 | import '@open-ibc/vibc-core-smart-contracts/contracts/libs/Ibc.sol';
  6 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcReceiver.sol';
  7 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcDispatcher.sol';
  8 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcMiddleware.sol';
  9 | 
 10 | contract GeneralMiddleware is IbcMwUser, IbcMiddleware, IbcMwEventsEmitter {
 11 |     /**
 12 |      * @dev MW_ID is the ID of MW contract on all supported virtual chains.
 13 |      * MW_ID must:
 14 |      * - be globally unique, ie. no two MWs should have the same MW_ID registered on Polymer chain.
 15 |      * - be identical on all supported virtual chains.
 16 |      * - be identical on one virtual chain across multiple deployed MW instances. Each MW instance belong exclusively to one MW stack.
 17 |      * - be 1 << N, where N is a non-negative integer, and not in conflict with other MWs.
 18 |      */
 19 |     uint256 public MW_ID;
 20 | 
 21 |     /**
 22 |      * @param _middleware The middleware contract address this contract sends packets to and receives packets from.
 23 |      */
 24 | 
 25 |     constructor(uint256 mwId, address _middleware) IbcMwUser(_middleware) {
 26 |         MW_ID = mwId;
 27 |     }
 28 | 
 29 |     function sendUniversalPacket(
 30 |         bytes32 channelId,
 31 |         bytes32 destPortAddr,
 32 |         bytes calldata appData,
 33 |         uint64 timeoutTimestamp
 34 |     ) external override {
 35 |         _sendPacket(channelId, IbcUtils.toBytes32(msg.sender), destPortAddr, 0, appData, timeoutTimestamp);
 36 |     }
 37 | 
 38 |     function sendMWPacket(
 39 |         bytes32 channelId,
 40 |         bytes32 srcPortAddr,
 41 |         bytes32 destPortAddr,
 42 |         uint256 srcMwIds,
 43 |         bytes calldata appData,
 44 |         uint64 timeoutTimestamp
 45 |     ) external override {
 46 |         _sendPacket(channelId, srcPortAddr, destPortAddr, srcMwIds, appData, timeoutTimestamp);
 47 |     }
 48 | 
 49 |     function onRecvMWPacket(
 50 |         bytes32 channelId,
 51 |         UniversalPacket calldata ucPacket,
 52 |         // address srcPortAddr,
 53 |         // address destPortAddr,
 54 |         // 0-based receiver middleware index in the MW stack.
 55 |         //  0 for the first MW directly called by UniversalChannel MW.
 56 |         // `mwIndex-1` is the last MW that delivers the packet to the non-MW dApp.
 57 |         // Each mw in the stack must increment mwIndex by 1 before calling the next MW.
 58 |         uint256 mwIndex,
 59 |         // bytes calldata appData,
 60 |         address[] calldata mwAddrs
 61 |     ) external onlyIbcMw returns (AckPacket memory ackPacket) {
 62 |         // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
 63 |         // implementer can emit custom data fields suitable for their use cases.
 64 |         // Here we use MW_ID as the custom MW data field.
 65 |         emit RecvMWPacket(
 66 |             channelId,
 67 |             ucPacket.srcPortAddr,
 68 |             ucPacket.destPortAddr,
 69 |             MW_ID,
 70 |             ucPacket.appData,
 71 |             abi.encodePacked(MW_ID)
 72 |         );
 73 | 
 74 |         if (mwIndex == mwAddrs.length - 1) {
 75 |             // last MW in the stack, deliver packet to dApp
 76 |             return
 77 |                 IbcUniversalPacketReceiver(IbcUtils.toAddress(ucPacket.destPortAddr)).onRecvUniversalPacket(
 78 |                     channelId,
 79 |                     ucPacket
 80 |                 );
 81 |         } else {
 82 |             // send packet to next MW
 83 |             return IbcMwPacketReceiver(mwAddrs[mwIndex + 1]).onRecvMWPacket(channelId, ucPacket, mwIndex + 1, mwAddrs);
 84 |         }
 85 |     }
 86 | 
 87 |     function onRecvMWAck(
 88 |         bytes32 channelId,
 89 |         UniversalPacket calldata ucPacket,
 90 |         // 0-based receiver middleware index in the MW stack.
 91 |         //  0 for the first MW directly called by UniversalChannel MW.
 92 |         // `mwIndex-1` is the last MW that delivers the packet to the non-MW dApp.
 93 |         // Each mw in the stack must increment mwIndex by 1 before calling the next MW.
 94 |         uint256 mwIndex,
 95 |         address[] calldata mwAddrs,
 96 |         AckPacket calldata ack
 97 |     ) external override onlyIbcMw {
 98 |         // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
 99 |         // implementer can emit custom data fields suitable for their use cases.
100 |         // Here we use MW_ID as the custom MW data field.
101 |         emit RecvMWAck(
102 |             channelId,
103 |             ucPacket.srcPortAddr,
104 |             ucPacket.destPortAddr,
105 |             MW_ID,
106 |             ucPacket.appData,
107 |             abi.encodePacked(MW_ID),
108 |             ack
109 |         );
110 | 
111 |         if (mwIndex == mwAddrs.length - 1) {
112 |             // last MW in the stack, deliver ack to dApp
113 |             IbcUniversalPacketReceiver(IbcUtils.toAddress(ucPacket.srcPortAddr)).onUniversalAcknowledgement(
114 |                 channelId,
115 |                 ucPacket,
116 |                 ack
117 |             );
118 |         } else {
119 |             // send ack to next MW
120 |             IbcMwPacketReceiver(mwAddrs[mwIndex + 1]).onRecvMWAck(channelId, ucPacket, mwIndex + 1, mwAddrs, ack);
121 |         }
122 |     }
123 | 
124 |     function onRecvMWTimeout(
125 |         bytes32 channelId,
126 |         UniversalPacket calldata ucPacket,
127 |         uint256 mwIndex,
128 |         address[] calldata mwAddrs
129 |     ) external override onlyIbcMw {
130 |         // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
131 |         // implementer can emit custom data fields suitable for their use cases.
132 |         // Here we use MW_ID as the custom MW data field.
133 |         emit RecvMWTimeout(
134 |             channelId,
135 |             ucPacket.srcPortAddr,
136 |             ucPacket.destPortAddr,
137 |             MW_ID,
138 |             ucPacket.appData,
139 |             abi.encodePacked(MW_ID)
140 |         );
141 | 
142 |         if (mwIndex == mwAddrs.length - 1) {
143 |             // last MW in the stack, deliver timeout to dApp
144 |             IbcUniversalPacketReceiver(IbcUtils.toAddress(ucPacket.srcPortAddr)).onTimeoutUniversalPacket(
145 |                 channelId,
146 |                 ucPacket
147 |             );
148 |         } else {
149 |             // send timeout to next MW
150 |             IbcMwPacketReceiver(mwAddrs[mwIndex + 1]).onRecvMWTimeout(channelId, ucPacket, mwIndex + 1, mwAddrs);
151 |         }
152 |     }
153 | 
154 |     function onRecvUniversalPacket(
155 |         bytes32 channelId,
156 |         UniversalPacket calldata ucPacket
157 |     ) external override onlyIbcMw returns (AckPacket memory ackPacket) {}
158 | 
159 |     function onUniversalAcknowledgement(
160 |         bytes32 channelId,
161 |         UniversalPacket memory packet,
162 |         AckPacket calldata ack
163 |     ) external override onlyIbcMw {}
164 | 
165 |     function onTimeoutUniversalPacket(bytes32 channelId, UniversalPacket calldata packet) external override onlyIbcMw {}
166 | 
167 |     // internal function to send packet to next MW with MW Ids bit flipped
168 |     // param srcMwIds: MW ID bitmap excluding this MW's ID
169 |     function _sendPacket(
170 |         bytes32 channelId,
171 |         bytes32 srcPortAddr,
172 |         bytes32 destPortAddr,
173 |         uint256 srcMwIds,
174 |         bytes calldata appData,
175 |         uint64 timeoutTimestamp
176 |     ) internal virtual {
177 |         // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
178 |         // implementer can emit custom data fields suitable for their use cases.
179 |         // Here we use MW_ID as the custom MW data field.
180 |         emit SendMWPacket(
181 |             channelId,
182 |             srcPortAddr,
183 |             destPortAddr,
184 |             MW_ID,
185 |             appData,
186 |             timeoutTimestamp,
187 |             abi.encodePacked(MW_ID)
188 |         );
189 | 
190 |         // send packet to next MW
191 |         IbcMwPacketSender(mw).sendMWPacket(
192 |             channelId,
193 |             srcPortAddr,
194 |             destPortAddr,
195 |             srcMwIds | MW_ID,
196 |             appData,
197 |             timeoutTimestamp
198 |         );
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/contracts/x-ballot-nft/XBallot.sol:
--------------------------------------------------------------------------------
  1 | //SPDX-License-Identifier: UNLICENSED
  2 | 
  3 | pragma solidity ^0.8.9;
  4 | 
  5 | import '../base/CustomChanIbcApp.sol';
  6 | 
  7 | /** 
  8 |  * @title XBallot
  9 |  * @dev Implements voting process along with vote delegation, 
 10 |  * and ability to send cross-chain instruction to mint NFT on counterparty
 11 |  */
 12 | contract XBallot is CustomChanIbcApp {
 13 |     enum IbcPacketStatus {UNSENT, SENT, ACKED, TIMEOUT}
 14 | 
 15 |     struct Voter {
 16 |         uint weight; // weight is accumulated by delegation
 17 |         bool voted;  // if true, that person already voted;    
 18 |         address delegate; // person delegated to
 19 |         uint vote;   // index of the voted proposal
 20 |         // additional
 21 |         IbcPacketStatus ibcPacketStatus;
 22 |         uint[] voteNFTIds;
 23 |     }
 24 | 
 25 |     struct Proposal {
 26 |         // If you can limit the length to a certain number of bytes, 
 27 |         // always use one of bytes1 to bytes32 because they are much cheaper
 28 |         bytes32 name;   // short name (up to 32 bytes)
 29 |         uint voteCount; // number of accumulated votes
 30 |     }
 31 | 
 32 |     address public chairperson;
 33 | 
 34 |     mapping(address => Voter) public voters;
 35 | 
 36 |     Proposal[] public proposals;
 37 | 
 38 |     modifier onlyChairperson() {
 39 |         require(msg.sender == chairperson, "Not chairperson.");
 40 |         _;
 41 |     }
 42 | 
 43 |     event Voted(address indexed voter, uint proposal);  // Exposing the vote information for debugging; hide in production if you want private voting
 44 |     event SendVoteInfo(bytes32 channelId, address indexed voter, address indexed recipient, uint proposal);
 45 |     event AckNFTMint(bytes32 channelId, uint sequence, address indexed voter, uint voteNFTid);
 46 | 
 47 |     /** 
 48 |      * @dev Create a new ballot to choose one of 'proposalNames' and make it IBC enabled to send proof of Vote to counterparty
 49 |      * @param _dispatcher vIBC dispatcher contract
 50 |      * @param proposalNames names of proposals
 51 |      */
 52 |     constructor( IbcDispatcher _dispatcher, bytes32[] memory proposalNames) CustomChanIbcApp(_dispatcher) {
 53 |         chairperson = msg.sender;
 54 |         voters[chairperson].weight = 1;
 55 | 
 56 |         for (uint i = 0; i < proposalNames.length; i++) {
 57 |             // 'Proposal({...})' creates a temporary
 58 |             // Proposal object and 'proposals.push(...)'
 59 |             // appends it to the end of 'proposals'.
 60 |             proposals.push(Proposal({
 61 |                 name: proposalNames[i],
 62 |                 voteCount: 0
 63 |             }));
 64 |         }
 65 |     }
 66 | 
 67 |     /** 
 68 |      * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
 69 |      * @param voter address of voter
 70 |      */
 71 |     function giveRightToVote(address voter) public {
 72 |         require(
 73 |             msg.sender == chairperson,
 74 |             "Only chairperson can give right to vote."
 75 |         );
 76 |         require(
 77 |             !voters[voter].voted,
 78 |             "The voter already voted."
 79 |         );
 80 |         require(voters[voter].weight == 0);
 81 |         voters[voter].weight = 1;
 82 |     }
 83 | 
 84 |     /**
 85 |      * @dev Delegate your vote to the voter 'to'.
 86 |      * @param to address to which vote is delegated
 87 |      */
 88 |     function delegate(address to) public {
 89 |         Voter storage sender = voters[msg.sender];
 90 |         require(!sender.voted, "You already voted.");
 91 |         require(to != msg.sender, "Self-delegation is disallowed.");
 92 | 
 93 |         while (voters[to].delegate != address(0)) {
 94 |             to = voters[to].delegate;
 95 | 
 96 |             // We found a loop in the delegation, not allowed.
 97 |             require(to != msg.sender, "Found loop in delegation.");
 98 |         }
 99 |         sender.voted = true;
100 |         sender.delegate = to;
101 |         Voter storage delegate_ = voters[to];
102 |         if (delegate_.voted) {
103 |             // If the delegate already voted,
104 |             // directly add to the number of votes
105 |             proposals[delegate_.vote].voteCount += sender.weight;
106 |         } else {
107 |             // If the delegate did not vote yet,
108 |             // add to her weight.
109 |             delegate_.weight += sender.weight;
110 |         }
111 |     }
112 | 
113 |     /**
114 |      * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
115 |      * @param proposal index of proposal in the proposals array
116 |      */
117 |     function vote(uint proposal) public {
118 |         Voter storage sender = voters[msg.sender];
119 |         // FOR TESTING ONLY
120 |         // ----------------
121 |         sender.weight = 1;
122 |         sender.ibcPacketStatus = IbcPacketStatus.UNSENT;
123 |         require(sender.weight != 0, "Has no right to vote");
124 |         // require(!sender.voted, "Already voted.");
125 |         // ----------------
126 |         sender.voted = true;
127 |         sender.vote = proposal;
128 | 
129 |         // If 'proposal' is out of the range of the array,
130 |         // this will throw automatically and revert all
131 |         // changes.
132 |         proposals[proposal].voteCount += sender.weight;
133 | 
134 |         emit Voted(msg.sender, proposal);
135 |     }
136 | 
137 | 
138 |     /** 
139 |      * @dev Computes the winning proposal taking all previous votes into account.
140 |      * @return winningProposal_ index of winning proposal in the proposals array
141 |      */
142 |     function winningProposal() public view
143 |             returns (uint winningProposal_)
144 |     {
145 |         uint winningVoteCount = 0;
146 |         for (uint p = 0; p < proposals.length; p++) {
147 |             if (proposals[p].voteCount > winningVoteCount) {
148 |                 winningVoteCount = proposals[p].voteCount;
149 |                 winningProposal_ = p;
150 |             }
151 |         }
152 |     }
153 | 
154 |     /** 
155 |      * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
156 |      * @return winnerName_ the name of the winner
157 |      */
158 |     function winnerName() public view
159 |             returns (bytes32 winnerName_)
160 |     {
161 |         winnerName_ = proposals[winningProposal()].name;
162 |     }
163 | 
164 |     // IBC methods
165 | 
166 |     /**
167 |      * @dev Sends a packet with a greeting message over a specified channel.
168 |      * @param channelId The ID of the channel to send the packet to.
169 |      * @param timeoutSeconds The timeout in seconds (relative).
170 |      * @param voterAddress the address of the voter
171 |      * @param recipient the address on the destination (Base) that will have NFT minted
172 |      */
173 |     function sendPacket(
174 |         bytes32 channelId,
175 |         uint64 timeoutSeconds,
176 |         address voterAddress,
177 |         address recipient
178 |     ) external {
179 |         Voter storage voter = voters[voterAddress];
180 |         require(voter.ibcPacketStatus == IbcPacketStatus.UNSENT || voter.ibcPacketStatus == IbcPacketStatus.TIMEOUT, "An IBC packet relating to his vote has already been sent. Wait for acknowledgement.");
181 | 
182 |         uint proposal = voter.vote;
183 |         bytes memory payload = abi.encode(voterAddress, recipient);
184 | 
185 |         uint64 timeoutTimestamp = uint64((block.timestamp + timeoutSeconds) * 1000000000);
186 | 
187 |         dispatcher.sendPacket(channelId, payload, timeoutTimestamp);
188 |         voter.ibcPacketStatus = IbcPacketStatus.SENT;
189 | 
190 |         emit SendVoteInfo(channelId, voterAddress, recipient, proposal);
191 |     }
192 | 
193 |     function onRecvPacket(IbcPacket memory) external override view onlyIbcDispatcher returns (AckPacket memory ackPacket) {
194 |         require(false, "This function should not be called");
195 | 
196 |         return AckPacket(true, abi.encode("Error: This function should not be called"));
197 |     }
198 | 
199 |     function onAcknowledgementPacket(IbcPacket calldata packet, AckPacket calldata ack) external override onlyIbcDispatcher {
200 |         ackPackets.push(ack);
201 |         
202 |         // decode the ack data, find the address of the voter the packet belongs to and set ibcNFTMinted true
203 |         (address voterAddress, uint256 voteNFTid) = abi.decode(ack.data, (address, uint256));
204 |         voters[voterAddress].ibcPacketStatus = IbcPacketStatus.ACKED;
205 |         voters[voterAddress].voteNFTIds.push(voteNFTid);
206 | 
207 |         emit AckNFTMint(packet.src.channelId, packet.sequence, voterAddress, voteNFTid);
208 |     }
209 | 
210 |     function onTimeoutPacket(IbcPacket calldata packet) external override onlyIbcDispatcher {
211 |         timeoutPackets.push(packet);
212 |         // do logic
213 |     }
214 | }


--------------------------------------------------------------------------------
/contracts/x-ballot-nft-UC/XBallotUC.sol:
--------------------------------------------------------------------------------
  1 | //SPDX-License-Identifier: UNLICENSED
  2 | 
  3 | pragma solidity ^0.8.9;
  4 | 
  5 | import '../base/UniversalChanIbcApp.sol';
  6 | 
  7 | contract XBallotUC is UniversalChanIbcApp {
  8 |     enum IbcPacketStatus {UNSENT, SENT, ACKED, TIMEOUT}
  9 | 
 10 |     struct Voter {
 11 |         uint weight; // weight is accumulated by delegation
 12 |         bool voted;  // if true, that person already voted;    
 13 |         address delegate; // person delegated to
 14 |         uint vote;   // index of the voted proposal
 15 |         // additional
 16 |         IbcPacketStatus ibcPacketStatus;
 17 |         uint[] voteNFTIds;    
 18 |     }
 19 | 
 20 |     struct Proposal {
 21 |         // If you can limit the length to a certain number of bytes, 
 22 |         // always use one of bytes1 to bytes32 because they are much cheaper
 23 |         bytes32 name;   // short name (up to 32 bytes)
 24 |         uint voteCount; // number of accumulated votes
 25 |     }
 26 | 
 27 |     address public chairperson;
 28 | 
 29 |     mapping(address => Voter) public voters;
 30 | 
 31 |     Proposal[] public proposals;
 32 | 
 33 |     modifier onlyChairperson() {
 34 |         require(msg.sender == chairperson, "Not chairperson.");
 35 |         _;
 36 |     }
 37 | 
 38 |     event Voted(address indexed voter, uint proposal);  // Exposing the vote information for debugging; hide in production if you want private voting
 39 |     event SendVoteInfo(address indexed destPortAddr, address indexed voter, address indexed recipient, uint proposal);
 40 |     event AckNFTMint(address indexed destPortAddr, address indexed voter, uint voteNFTid);
 41 | 
 42 | 
 43 |     constructor(address _middleware, bytes32[] memory proposalNames) UniversalChanIbcApp(_middleware) {
 44 |         chairperson = msg.sender;
 45 |         voters[chairperson].weight = 1;
 46 | 
 47 |         for (uint i = 0; i < proposalNames.length; i++) {
 48 |             // 'Proposal({...})' creates a temporary
 49 |             // Proposal object and 'proposals.push(...)'
 50 |             // appends it to the end of 'proposals'.
 51 |             proposals.push(Proposal({
 52 |                 name: proposalNames[i],
 53 |                 voteCount: 0
 54 |             }));
 55 |         }
 56 |     }
 57 | 
 58 |     /** 
 59 |      * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
 60 |      * @param voter address of voter
 61 |      */
 62 |     function giveRightToVote(address voter) public {
 63 |         require(
 64 |             msg.sender == chairperson,
 65 |             "Only chairperson can give right to vote."
 66 |         );
 67 |         require(
 68 |             !voters[voter].voted,
 69 |             "The voter already voted."
 70 |         );
 71 |         require(voters[voter].weight == 0);
 72 |         voters[voter].weight = 1;
 73 |     }
 74 | 
 75 |     /**
 76 |      * @dev Delegate your vote to the voter 'to'.
 77 |      * @param to address to which vote is delegated
 78 |      */
 79 |     function delegate(address to) public {
 80 |         Voter storage sender = voters[msg.sender];
 81 |         require(!sender.voted, "You already voted.");
 82 |         require(to != msg.sender, "Self-delegation is disallowed.");
 83 | 
 84 |         while (voters[to].delegate != address(0)) {
 85 |             to = voters[to].delegate;
 86 | 
 87 |             // We found a loop in the delegation, not allowed.
 88 |             require(to != msg.sender, "Found loop in delegation.");
 89 |         }
 90 |         sender.voted = true;
 91 |         sender.delegate = to;
 92 |         Voter storage delegate_ = voters[to];
 93 |         if (delegate_.voted) {
 94 |             // If the delegate already voted,
 95 |             // directly add to the number of votes
 96 |             proposals[delegate_.vote].voteCount += sender.weight;
 97 |         } else {
 98 |             // If the delegate did not vote yet,
 99 |             // add to her weight.
100 |             delegate_.weight += sender.weight;
101 |         }
102 |     }
103 | 
104 |     /**
105 |      * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
106 |      * @param proposal index of proposal in the proposals array
107 |      */
108 |     function vote(uint proposal) public {
109 |         Voter storage sender = voters[msg.sender];
110 |         // FOR TESTING ONLY
111 |         // ----------------
112 |         sender.weight = 1;
113 |         sender.ibcPacketStatus = IbcPacketStatus.UNSENT;
114 |         require(sender.weight != 0, "Has no right to vote");
115 |         // require(!sender.voted, "Already voted.");
116 |         // ----------------
117 |         sender.voted = true;
118 |         sender.vote = proposal;
119 | 
120 |         // If 'proposal' is out of the range of the array,
121 |         // this will throw automatically and revert all
122 |         // changes.
123 |         proposals[proposal].voteCount += sender.weight;
124 | 
125 |         emit Voted(msg.sender, proposal);
126 |     }
127 | 
128 | 
129 |     /** 
130 |      * @dev Computes the winning proposal taking all previous votes into account.
131 |      * @return winningProposal_ index of winning proposal in the proposals array
132 |      */
133 |     function winningProposal() public view
134 |             returns (uint winningProposal_)
135 |     {
136 |         uint winningVoteCount = 0;
137 |         for (uint p = 0; p < proposals.length; p++) {
138 |             if (proposals[p].voteCount > winningVoteCount) {
139 |                 winningVoteCount = proposals[p].voteCount;
140 |                 winningProposal_ = p;
141 |             }
142 |         }
143 |     }
144 | 
145 |     /** 
146 |      * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
147 |      * @return winnerName_ the name of the winner
148 |      */
149 |     function winnerName() public view
150 |             returns (bytes32 winnerName_)
151 |     {
152 |         winnerName_ = proposals[winningProposal()].name;
153 |     }
154 | 
155 |     /**
156 |      * @dev Sends a packet with a greeting message over a specified channel.
157 |      * @param destPortAddr The address of the destination application to be used in the port identifier.
158 |      * @param channelId The ID of the channel to send the packet to.
159 |      * @param timeoutSeconds The timeout in seconds (relative).
160 |      * @param voterAddress the address of the voter
161 |      * @param recipient the address on the destination (Base) that will have NFT minted
162 |      */
163 | 
164 |     function sendUniversalPacket(
165 |         address destPortAddr,
166 |         bytes32 channelId, 
167 |         uint64 timeoutSeconds,
168 |         address voterAddress,
169 |         address recipient
170 |         ) external {
171 |         Voter storage voter = voters[voterAddress];
172 |         require(voter.ibcPacketStatus == IbcPacketStatus.UNSENT || voter.ibcPacketStatus == IbcPacketStatus.TIMEOUT, "An IBC packet relating to his vote has already been sent. Wait for acknowledgement.");
173 | 
174 |         uint propsoal = voter.vote;
175 |         bytes memory payload = abi.encode(voterAddress, recipient);
176 | 
177 |         uint64 timeoutTimestamp = uint64((block.timestamp + timeoutSeconds) * 1000000000);
178 | 
179 |         IbcUniversalPacketSender(mw).sendUniversalPacket(
180 |             channelId,
181 |             IbcUtils.toBytes32(destPortAddr),
182 |             payload,
183 |             timeoutTimestamp
184 |         );
185 |         voter.ibcPacketStatus = IbcPacketStatus.SENT;
186 | 
187 |         emit SendVoteInfo(destPortAddr, voterAddress, recipient, propsoal);
188 |     }
189 | 
190 |     function onRecvUniversalPacket(
191 |         bytes32,
192 |         UniversalPacket calldata
193 |     ) external override view onlyIbcMw returns (AckPacket memory ackPacket) {
194 |         require(false, "This function should not be called");
195 | 
196 |         return AckPacket(true, abi.encode("Error: This function should not be called"));
197 |     }
198 | 
199 |     function onUniversalAcknowledgement(
200 |             bytes32 channelId,
201 |             UniversalPacket memory packet,
202 |             AckPacket calldata ack
203 |     ) external override onlyIbcMw {
204 |         ackPackets.push(UcAckWithChannel(channelId, packet, ack));
205 | 
206 |         // decode the ack data, find the address of the voter the packet belongs to and set ibcNFTMinted true
207 |         (address voterAddress, uint256 voteNFTid) = abi.decode(ack.data, (address, uint256));
208 |         voters[voterAddress].ibcPacketStatus = IbcPacketStatus.ACKED;
209 |         voters[voterAddress].voteNFTIds.push(voteNFTid);
210 | 
211 |         emit AckNFTMint(IbcUtils.toAddress(packet.destPortAddr), voterAddress, voteNFTid);
212 |     }
213 | 
214 |     function onTimeoutUniversalPacket(
215 |         bytes32 channelId, 
216 |         UniversalPacket calldata packet
217 |     ) external override onlyIbcMw {
218 |         timeoutPackets.push(UcPacketWithChannel(channelId, packet));
219 |         // Timeouts not currently supported
220 |     }
221 | }
222 | 


--------------------------------------------------------------------------------
/contracts/base/CustomChanIbcApp.sol:
--------------------------------------------------------------------------------
  1 | //SPDX-License-Identifier: UNLICENSED
  2 | 
  3 | pragma solidity ^0.8.9;
  4 | 
  5 | import '@open-ibc/vibc-core-smart-contracts/contracts/libs/Ibc.sol';
  6 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcReceiver.sol';
  7 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcDispatcher.sol';
  8 | import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/ProofVerifier.sol';
  9 | 
 10 | // CustomChanIbcApp is a contract that can be used as a base contract
 11 | // for IBC-enabled contracts that send packets over a custom IBC channel.
 12 | contract CustomChanIbcApp is IbcReceiverBase, IbcReceiver {
 13 |     // received packet as chain B
 14 |     IbcPacket[] public recvedPackets;
 15 |     // received ack packet as chain A
 16 |     AckPacket[] public ackPackets;
 17 |     // received timeout packet as chain A
 18 |     IbcPacket[] public timeoutPackets;
 19 |     
 20 |     struct ChannelMapping {
 21 |         bytes32 channelId;
 22 |         bytes32 cpChannelId;
 23 |     }
 24 |     
 25 |     // ChannelMapping array with the channel IDs of the connected channels
 26 |     ChannelMapping[] public connectedChannels;
 27 | 
 28 |     // add supported versions (format to be negotiated between apps)
 29 |     string[] supportedVersions = ['1.0'];
 30 | 
 31 |     constructor(IbcDispatcher _dispatcher) IbcReceiverBase(_dispatcher) {}
 32 | 
 33 |     function updateDispatcher(IbcDispatcher _dispatcher) external onlyOwner {
 34 |         dispatcher = _dispatcher;
 35 |     }
 36 | 
 37 |     function getConnectedChannels() external view returns (ChannelMapping[] memory) {
 38 |         return connectedChannels;
 39 |     }
 40 | 
 41 |     function updateSupportedVersions(string[] memory _supportedVersions) external onlyOwner {
 42 |         supportedVersions = _supportedVersions;
 43 |     }
 44 | 
 45 |     /** 
 46 |      * @dev Implement a function to send a packet that calls the dispatcher.sendPacket function
 47 |      *      It has the following function handle:
 48 |      *          function sendPacket(bytes32 channelId, bytes calldata payload, uint64 timeoutTimestamp) external;
 49 |      */
 50 | 
 51 |     /**
 52 |      * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
 53 |      *      MUST be overriden by the inheriting contract.
 54 |      * 
 55 |      * @param packet the IBC packet encoded by the source and relayed by the relayer.
 56 |      */
 57 |     function onRecvPacket(IbcPacket memory packet) external virtual onlyIbcDispatcher returns (AckPacket memory ackPacket) {
 58 |         recvedPackets.push(packet);
 59 |         // do logic
 60 |         return AckPacket(true, abi.encodePacked('{ "account": "account", "reply": "got the message" }'));
 61 |     }
 62 | 
 63 |     /**
 64 |      * @dev Packet lifecycle callback that implements packet acknowledgment logic.
 65 |      *      MUST be overriden by the inheriting contract.
 66 |      * 
 67 |      * @param packet the IBC packet encoded by the source and relayed by the relayer.
 68 |      * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
 69 |      */
 70 |     function onAcknowledgementPacket(IbcPacket calldata packet, AckPacket calldata ack) external virtual onlyIbcDispatcher {
 71 |         ackPackets.push(ack);
 72 |         // do logic
 73 |     }
 74 | 
 75 |     /**
 76 |      * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
 77 |      *      MUST be overriden by the inheriting contract.
 78 |      *      NOT SUPPORTED YET
 79 |      * 
 80 |      * @param packet the IBC packet encoded by the counterparty and relayed by the relayer
 81 |      */
 82 |     function onTimeoutPacket(IbcPacket calldata packet) external virtual onlyIbcDispatcher {
 83 |         timeoutPackets.push(packet);
 84 |         // do logic
 85 |     }
 86 | 
 87 |     /**
 88 |      * @dev Create a custom channel between two IbcReceiver contracts
 89 |      * @param local a CounterParty struct with the local chain's portId and version (channelId can be empty)
 90 |      * @param ordering the channel ordering (NONE, UNORDERED, ORDERED) equivalent to (0, 1, 2)
 91 |      * @param feeEnabled in production, you'll want to enable this to avoid spamming create channel calls (costly for relayers)
 92 |      * @param connectionHops 2 connection hops to connect to the destination via Polymer
 93 |      * @param counterparty the address of the destination chain contract you want to connect to
 94 |      * @param proof ICS23 proof struct with dummy data (only needed on ChanOpenTry)
 95 |      */
 96 |     function createChannel(
 97 |         CounterParty calldata local,
 98 |         uint8 ordering,
 99 |         bool feeEnabled, 
100 |         string[] calldata connectionHops, 
101 |         CounterParty calldata counterparty, 
102 |         Ics23Proof calldata proof
103 |         ) external virtual onlyOwner{
104 | 
105 |         dispatcher.openIbcChannel(
106 |             IbcChannelReceiver(address(this)),
107 |             local,
108 |             ChannelOrder(ordering),
109 |             feeEnabled,
110 |             connectionHops,
111 |             counterparty,
112 |             proof
113 |         );
114 |     }
115 | 
116 |     function onOpenIbcChannel(
117 |         string calldata version,
118 |         ChannelOrder,
119 |         bool,
120 |         string[] calldata,
121 |         CounterParty calldata counterparty
122 |     ) external view virtual onlyIbcDispatcher returns (string memory selectedVersion) {
123 |         if (bytes(counterparty.portId).length <= 8) {
124 |             revert invalidCounterPartyPortId();
125 |         }
126 |         /**
127 |          * Version selection is determined by if the callback is invoked on behalf of ChanOpenInit or ChanOpenTry.
128 |          * ChanOpenInit: self version should be provided whereas the counterparty version is empty.
129 |          * ChanOpenTry: counterparty version should be provided whereas the self version is empty.
130 |          * In both cases, the selected version should be in the supported versions list.
131 |          */
132 |         bool foundVersion = false;
133 |         selectedVersion = keccak256(abi.encodePacked(version)) == keccak256(abi.encodePacked(''))
134 |             ? counterparty.version
135 |             : version;
136 |         for (uint256 i = 0; i < supportedVersions.length; i++) {
137 |             if (keccak256(abi.encodePacked(selectedVersion)) == keccak256(abi.encodePacked(supportedVersions[i]))) {
138 |                 foundVersion = true;
139 |                 break;
140 |             }
141 |         }
142 |         require(foundVersion, 'Unsupported version');
143 |         // if counterpartyVersion is not empty, then it must be the same foundVersion
144 |         if (keccak256(abi.encodePacked(counterparty.version)) != keccak256(abi.encodePacked(''))) {
145 |             require(
146 |                 keccak256(abi.encodePacked(counterparty.version)) == keccak256(abi.encodePacked(selectedVersion)),
147 |                 'Version mismatch'
148 |             );
149 |         }
150 | 
151 |         // do logic
152 | 
153 |         return selectedVersion;
154 |     }
155 | 
156 |     function onConnectIbcChannel(
157 |         bytes32 channelId,
158 |         bytes32 counterpartyChannelId,
159 |         string calldata counterpartyVersion
160 |     ) external virtual onlyIbcDispatcher {
161 |         // ensure negotiated version is supported
162 |         bool foundVersion = false;
163 |         for (uint256 i = 0; i < supportedVersions.length; i++) {
164 |             if (keccak256(abi.encodePacked(counterpartyVersion)) == keccak256(abi.encodePacked(supportedVersions[i]))) {
165 |                 foundVersion = true;
166 |                 break;
167 |             }
168 |         }
169 |         require(foundVersion, 'Unsupported version');
170 | 
171 |         // do logic
172 | 
173 |         ChannelMapping memory channelMapping = ChannelMapping({
174 |             channelId: channelId,
175 |             cpChannelId: counterpartyChannelId
176 |         });
177 |         connectedChannels.push(channelMapping);
178 |     }
179 | 
180 |     function onCloseIbcChannel(bytes32 channelId, string calldata, bytes32) external virtual onlyIbcDispatcher {
181 |         // logic to determin if the channel should be closed
182 |         bool channelFound = false;
183 |         for (uint256 i = 0; i < connectedChannels.length; i++) {
184 |             if (connectedChannels[i].channelId == channelId) {
185 |                 for (uint256 j = i; j < connectedChannels.length - 1; j++) {
186 |                     connectedChannels[j] = connectedChannels[j + 1];
187 |                 }
188 |                 connectedChannels.pop();
189 |                 channelFound = true;
190 |                 break;
191 |             }
192 |         }
193 |         require(channelFound, 'Channel not found');
194 | 
195 |         // do logic
196 |     }
197 | 
198 |     /**
199 |      * This func triggers channel closure from the dApp.
200 |      * Func args can be arbitary, as long as dispatcher.closeIbcChannel is invoked propperly.
201 |      */
202 |     function triggerChannelClose(bytes32 channelId) external virtual onlyOwner {
203 |         dispatcher.closeIbcChannel(channelId);
204 |     }
205 | }
206 | 


--------------------------------------------------------------------------------
/scripts/private/_events.js:
--------------------------------------------------------------------------------
  1 | const hre = require("hardhat");
  2 | const { areAddressesEqual, getConfigPath } = require("./_helpers.js");
  3 | const { getDispatcher, getUcHandlerAddress } = require("./_vibc-helpers.js");
  4 | 
  5 | const explorerOpUrl = "https://optimism-sepolia.blockscout.com/";
  6 | const explorerBaseUrl = "https://base-sepolia.blockscout.com/";
  7 | 
  8 | function filterChannelEvents(portAddress) {
  9 |     const config = require(getConfigPath());
 10 |     return areAddressesEqual(portAddress, config.createChannel["srcAddr"]) || areAddressesEqual(portAddress, config.createChannel["dstAddr"]);
 11 | }
 12 | 
 13 | function listenForIbcChannelEvents(network, source, dispatcher) {
 14 |     const explorerUrl = network === "optimism" ? explorerOpUrl : explorerBaseUrl;
 15 |     console.log(`👂 Listening for IBC channel events on ${network}...`);
 16 |     dispatcher.on(
 17 |         "OpenIbcChannel",
 18 |         (portAddress, version, ordering, feeEnabled, connectionHops, counterparytPortId, counterpartyChannelId, event) => {
 19 |             const txHash = event.log.transactionHash;
 20 |             const counterpartyChannelIdString = hre.ethers.decodeBytes32String(counterpartyChannelId);
 21 |             const url = `${explorerUrl}tx/${txHash}`;
 22 | 
 23 |             if (filterChannelEvents(portAddress)) {
 24 |                 console.log(`
 25 |           -------------------------------------------`);
 26 |                 if (source) {
 27 |                     console.log(`
 28 |           🙋‍♀️   CHANNEL OPEN INIT !!!   🙋‍♀️`);
 29 |                 } else {
 30 |                     console.log(`
 31 |           🙋‍♂️   CHANNEL OPEN TRY !!!   🙋‍♂️`);
 32 |                 }
 33 | 
 34 |                 console.log(`
 35 |           -------------------------------------------
 36 |           🔔 Event name: ${event.log.fragment.name}
 37 |           ⛓️  Network: ${network}
 38 |           🔗 Port Address: ${portAddress}
 39 |           🔗 Counterparty Port ID: ${counterparytPortId}
 40 |           🛣️  Counterparty Channel ID: ${counterpartyChannelIdString}
 41 |           🦘 Connection Hops: ${connectionHops}
 42 |           🔀 Ordering: ${ordering}
 43 |           💰 Fee Enabled: ${feeEnabled}
 44 |           #️⃣  Version: ${version}
 45 |           -------------------------------------------
 46 |           🧾 TxHash: ${txHash}
 47 |           🔍 Explorer URL: ${url}
 48 |           -------------------------------------------\n`);
 49 | 
 50 |                 if (source) {
 51 |                     console.log(` ⏱️  Waiting for channel open try...`);
 52 |                 } else {
 53 |                     console.log(` ⏱️  Waiting for channel open ack...`);
 54 |                 }
 55 |             }
 56 |         }
 57 |     );
 58 | 
 59 |     dispatcher.on("ConnectIbcChannel", (portAddress, channelId, event) => {
 60 |         const txHash = event.log.transactionHash;
 61 |         const channelIdString = hre.ethers.decodeBytes32String(channelId);
 62 |         const url = `${explorerUrl}tx/${txHash}`;
 63 |         if (filterChannelEvents(portAddress)) {
 64 |             console.log(`
 65 |           -------------------------------------------`);
 66 |             if (source) {
 67 |                 console.log(`
 68 |           👩‍❤️‍💋‍👨   CHANNEL OPEN ACK !!!   👩‍❤️‍💋‍👨`);
 69 |             } else {
 70 |                 console.log(`
 71 |           🤵‍♂️💍👰‍♀️   CHANNEL OPEN CONFIRM !!!   👰‍♀️💍🤵‍♂️`);
 72 |             }
 73 |             console.log(`
 74 |           -------------------------------------------
 75 |           🔔 Event name: ${event.log.fragment.name}
 76 |           ⛓️  Network: ${network}
 77 |           🔗 Port Address: ${portAddress}
 78 |           🛣️  Channel ID: ${channelIdString}
 79 |           -------------------------------------------
 80 |           🧾 TxHash: ${txHash}
 81 |           🔍 Explorer URL: ${url}
 82 |           -------------------------------------------\n`);
 83 |             if (source) {
 84 |                 console.log(` ⏱️  Waiting for channel open confirm...`);
 85 |             } else {
 86 |                 console.log(` ⏱️  Waiting for channel creation overview...`);
 87 |             }
 88 |         }
 89 |         dispatcher.removeAllListeners();
 90 |     });
 91 | 
 92 |     dispatcher.on("CloseIbcChannel", (portAddress, channelId, event) => {
 93 |         const txHash = event.log.transactionHash;
 94 |         const channelIdString = hre.ethers.decodeBytes32String(channelId);
 95 |         const url = `${explorerUrl}tx/${txHash}`;
 96 |         if (filterChannelEvents(portAddress)) {
 97 |             console.log(`
 98 |           -------------------------------------------
 99 |           🔗 🔒   IBC CHANNEL CLOSED !!!   🔗 🔒
100 |           -------------------------------------------
101 |           🔔 Event name: ${event.log.fragment.name}
102 |           ⛓️  Network: ${network}
103 |           🔗 Port Address: ${portAddress}
104 |           🛣️  Channel ID: ${channelIdString}
105 |           -------------------------------------------
106 |           🧾 TxHash: ${txHash}
107 |           🔍 Explorer URL: ${url}
108 |           -------------------------------------------\n`);
109 |         }
110 |         dispatcher.removeAllListeners();
111 |     });
112 | }
113 | 
114 | function filterPacketEvents(portAddress, network) {
115 |     const config = require(getConfigPath());
116 |     const sendPacketConfig = config.sendPacket;
117 |     const ucHandlerAddr = getUcHandlerAddress(network);
118 | 
119 |     return areAddressesEqual(portAddress, sendPacketConfig[`${network}`].portAddr) || areAddressesEqual(portAddress, ucHandlerAddr);
120 | }
121 | 
122 | function listenForIbcPacketEvents(network, dispatcher) {
123 |     const explorerUrl = network === "optimism" ? explorerOpUrl : explorerBaseUrl;
124 |     console.log(`👂 Listening for IBC packet events on ${network}...`);
125 | 
126 |     dispatcher.on("SendPacket", (sourcePortAddress, sourceChannelId, packet, sequence, timeoutTimestamp, event) => {
127 |         const txHash = event.log.transactionHash;
128 |         const sourceChannelIdString = hre.ethers.decodeBytes32String(sourceChannelId);
129 |         const url = `${explorerUrl}tx/${txHash}`;
130 | 
131 |         if (filterPacketEvents(sourcePortAddress, network)) {
132 |             console.log(` 
133 |           -------------------------------------------
134 |           📦 📮   PACKET HAS BEEN SENT !!!   📦 📮
135 |           -------------------------------------------
136 |           🔔 Event name: ${event.log.fragment.name}
137 |           ⛓️  Network: ${network}
138 |           🔗 Source Port Address: ${sourcePortAddress}
139 |           🛣️  Source Channel ID: ${sourceChannelIdString}
140 |           📈 Sequence: ${sequence}
141 |           ⏳ Timeout Timestamp: ${timeoutTimestamp}
142 |           -------------------------------------------
143 |           🧾 TxHash: ${txHash}
144 |           🔍 Explorer URL: ${url}
145 |           -------------------------------------------\n`);
146 |             console.log(` ⏱️  Waiting for packet receipt...`);
147 |         }
148 |     });
149 | 
150 |     dispatcher.on("RecvPacket", (destPortAddress, destChannelId, sequence, event) => {
151 |         const txHash = event.log.transactionHash;
152 |         const destChannelIdString = hre.ethers.decodeBytes32String(destChannelId);
153 |         const url = `${explorerUrl}tx/${txHash}`;
154 | 
155 |         if (filterPacketEvents(destPortAddress,network)) {
156 |             console.log(`
157 |           -------------------------------------------
158 |           📦 📬   PACKET IS RECEIVED !!!   📦 📬
159 |           -------------------------------------------
160 |           🔔 Event name: ${event.log.fragment.name}
161 |           ⛓️  Network: ${network}
162 |           🔗 Destination Port Address: ${destPortAddress}
163 |           🛣️  Destination Channel ID: ${destChannelIdString}
164 |           📈 Sequence: ${sequence}
165 |           -------------------------------------------
166 |           🧾 TxHash: ${txHash}
167 |           🔍 Explorer URL: ${url}
168 |           -------------------------------------------\n`);
169 |             console.log(` ⏱️  Waiting for write acknowledgement...`);
170 |         }
171 |     });
172 | 
173 |     dispatcher.on("WriteAckPacket", (writerPortAddress, writerChannelId, sequence, ackPacket, event) => {
174 |         const txHash = event.log.transactionHash;
175 |         const writerChannelIdString = hre.ethers.decodeBytes32String(writerChannelId);
176 |         const url = `${explorerUrl}tx/${txHash}`;
177 |         if (filterPacketEvents(writerPortAddress, network)) {
178 |             console.log(` 
179 |           -------------------------------------------
180 |           📦 📝   ACKNOWLEDGEMENT WRITTEN !!!   📦 📝
181 |           -------------------------------------------
182 |           🔔 Event name: ${event.log.fragment.name}
183 |           ⛓️  Network: ${network}
184 |           🔗 Destination Port Address: ${writerPortAddress}
185 |           🛣️  Channel ID: ${writerChannelIdString}
186 |           📈 Sequence: ${sequence}
187 |           -------------------------------------------
188 |           🧾 TxHash: ${txHash}
189 |           🔍 Explorer URL: ${url}
190 |           -------------------------------------------\n`);
191 |             console.log(` ⏱️  Waiting for acknowledgement...`);
192 |         }
193 |         dispatcher.removeAllListeners();
194 |     });
195 | 
196 |     dispatcher.on("Acknowledgement", (sourcePortAddress, sourceChannelId, sequence, event) => {
197 |         const txHash = event.log.transactionHash;
198 |         const sourceChannelIdString = hre.ethers.decodeBytes32String(sourceChannelId);
199 |         const url = `${explorerUrl}tx/${txHash}`;
200 |         if (filterPacketEvents(sourcePortAddress, network)) {
201 |             console.log(`   
202 |           -------------------------------------------
203 |           📦 🏁   PACKET IS ACKNOWLEDGED !!!   📦 🏁
204 |           -------------------------------------------
205 |           🔔 Event name: ${event.log.fragment.name}
206 |           ⛓️  Network: ${network}
207 |           🔗 Source Port Address: ${sourcePortAddress}
208 |           🛣️  Source Channel ID: ${sourceChannelIdString}
209 |           📈 Sequence: ${sequence}
210 |           -------------------------------------------
211 |           🧾 TxHash: ${txHash}
212 |           🔍 Explorer URL: ${url}
213 |           -------------------------------------------\n`);
214 |         }
215 |         dispatcher.removeAllListeners();
216 |     });
217 | }
218 | 
219 | async function setupIbcPacketEventListener() {
220 |     console.log("🔊 Setting up IBC packet event listener...")
221 |     // Get the dispatchers for both source and destination to listen for IBC packet events
222 |     const opDispatcher = await getDispatcher("optimism");
223 |     const baseDispatcher = await getDispatcher("base");
224 |     listenForIbcPacketEvents("optimism", opDispatcher);
225 |     listenForIbcPacketEvents("base", baseDispatcher);
226 | }
227 | 
228 | async function setupIbcChannelEventListener() {
229 |     console.log("🔊 Setting up IBC channel event listener...")
230 |     const config = require(getConfigPath());
231 |     const opIsSource = config.createChannel.srcChain === "optimism";
232 |     const baseIsSource = config.createChannel.srcChain === "base";
233 | 
234 |     // Get the dispatchers for both source and destination to listen for IBC packet events
235 |     const opDispatcher = await getDispatcher("optimism");
236 |     const baseDispatcher = await getDispatcher("base");
237 |     listenForIbcChannelEvents("optimism", opIsSource , opDispatcher);
238 |     listenForIbcChannelEvents("base", baseIsSource, baseDispatcher);
239 | }
240 | 
241 | module.exports = { listenForIbcChannelEvents, listenForIbcPacketEvents, setupIbcPacketEventListener, setupIbcChannelEventListener };
242 | 


--------------------------------------------------------------------------------
/ibc-app-template.md:
--------------------------------------------------------------------------------
  1 | # ⛓️🔗⛓️ Template for IBC enabled Solidity contracts
  2 | 
  3 | This repo provides a starter project to build [IBC](https://github.com/cosmos/ibc) enabled Solidity contracts that connect rollups to one another Polymer Hub, through the [vIBC core contracts](https://github.com/open-ibc/vibc-core-smart-contracts).
  4 | 
  5 | The repository is a _GitHub template_ repository so you can click "Use this template" to create your own project repository without having the entire commit history of the template.
  6 | 
  7 | ![GitHub template](./img/gh_template.png)
  8 | 
  9 | ## 📚 Documentation
 10 | 
 11 | There's some basic information here in the README but a more comprehensive documentation can be found in [the official Polymer documentation](https://docs.polymerlabs.org/docs/category/build-ibc-dapps-1).
 12 | 
 13 | ## 📋 Prerequisites
 14 | 
 15 | The repo is **compatible with both Hardhat and Foundry** development environments.
 16 | 
 17 | - Have [git](https://git-scm.com/downloads) installed
 18 | - Have [node](https://nodejs.org) installed (v18+)
 19 | - Have [Foundry](https://book.getfoundry.sh/getting-started/installation) installed (Hardhat will be installed when running `npm install`)
 20 | - Have [just](https://just.systems/man/en/chapter_1.html) installed (recommended but not strictly necessary)
 21 | 
 22 | You'll need some API keys from third party's:
 23 | - [Optimism Sepolia](https://optimism-sepolia.blockscout.com/account/api-key) and [Base Sepolia](https://base-sepolia.blockscout.com/account/api-key) Blockscout Explorer API keys
 24 | - Have an [Alchemy API key](https://docs.alchemy.com/docs/alchemy-quickstart-guide) for OP and Base Sepolia
 25 | 
 26 | Some basic knowledge of all of these tools is also required, although the details are abstracted away for basic usage.
 27 | 
 28 | ## 🧰 Install dependencies
 29 | 
 30 | To compile your contracts and start testing, make sure that you have all dependencies installed.
 31 | 
 32 | From the root directory run:
 33 | 
 34 | ```bash
 35 | just install
 36 | ```
 37 | 
 38 | to install the [vIBC core smart contracts](https://github.com/open-ibc/vibc-core-smart-contracts) as a dependency.
 39 | 
 40 | Additionally Hardhat will be installed as a dev dependency with some useful plugins. Check `package.json` for an exhaustive list.
 41 | 
 42 | > Note: In case you're experiencing issues with dependencies using the `just install` recipe, check that all prerequisites are correctly installed. If issues persist with forge, try to do the individual dependency installations...
 43 | 
 44 | ## ⚙️ Set up your environment variables
 45 | 
 46 | Convert the `.env.example` file into an `.env` file. This will ignore the file for future git commits as well as expose the environment variables. Add your private keys and update the other values if you want to customize (advanced usage feature).
 47 | 
 48 | ```bash
 49 | cp .env.example .env
 50 | ```
 51 | 
 52 | This will enable you to sign transactions with your private key(s). If not added, the scripts from the justfile will fail.
 53 | 
 54 | ### Configuration file
 55 | 
 56 | The configuration file is where all important data is stored for the just commands and automation. We strive to make direct interaction with the config file as little as possible.
 57 | 
 58 | By default the configuration file is stored at root as `config.json`.
 59 | 
 60 | However, it is recommended to split up different contracts/projects in the same repo into different config file in case you want to switch between them.
 61 | 
 62 | Store alternate config files in the /config directory and set
 63 | ```sh
 64 | # .env file
 65 | CONFIG_PATH='config/alt-config.json'
 66 | ```
 67 | to use a different config file.
 68 | 
 69 | ### Obtaining testnet ETH
 70 | 
 71 | The account associated with your private key must have both Base Sepolia and Optimism Sepolia ETH. To obtain the testnet ETH visit:
 72 | 
 73 | - [Optimism Sepolia Faucet](https://www.alchemy.com/faucets/optimism-sepolia)
 74 | - [Base Sepolia Faucet](https://www.alchemy.com/faucets/base-sepolia)
 75 | 
 76 | ## 🏃🏽🏃🏻‍♀️ Quickstart
 77 | 
 78 | The project comes with a built-in dummy application called x-counter (which syncrhonizes a counter across two contracts on remote chains). You can find the contracts in the `/contracts` directory as XCounterUC.sol and XCounter.sol (the former when using the universal channel, the latter when creating a custom IBC channel).
 79 | 
 80 | ### Universal channels
 81 | 
 82 | The easiest way to get onboarded is to use Universal channels. A universal channel is an IBC channel where the port is owned by Polymer's Universal channel middleware contracts on each chain.
 83 | 
 84 | When a user deploys a Universal channel compatible contract (this means inheriting the [UniversalChanIbcApp](./contracts/base/UniversalChanIbcApp.sol) base contract), it will be able to connect to the Universal Channel middleware, define Universal packets which will then be wrapped into an IBC packet by the Universal Channel Handler and unwrapped by its counterpart on the destination chain (rollup). The Universal channel middleware on the destination will then unwrap the IBC packet and send the data through to you application on the destination.
 85 | 
 86 | Find out more about uinversal channels in the [documenation](https://docs.polymerlabs.org/docs/build/ibc-solidity/universal-channel).
 87 | 
 88 | The configuration file that comes as default in the template repository, allows to quickly send a packet by running:
 89 | 
 90 | ```sh
 91 | just send-packet base
 92 | ```
 93 | 
 94 | To send a packet between the XCounterUC contract on Base Sepolia to OP Sepolia and vice versa.
 95 | 
 96 | You can find the universal channel middleware details [in the documentation](https://docs.polymerlabs.org/docs/build/supp-networks).
 97 | 
 98 | Check if the packet got through on the [Polymer IBC explorer](https://sepolia.polymer.zone/packets).
 99 | 
100 | ### Custom IBC channel
101 | 
102 | There's also a just recipe that quickly enables to try to send packets over a custom IBC channel. Custom IBC channel require a channel hanshake to open a private IBC channel (which can take a while depending on the client latency) but then give complete control over a private IBC channel that enables fault isolation from other applications, compared to unviersal channels.
103 | 
104 | To have your application be compatible with custom IBC channels, have it inherit the [CustomChanIbcApp](./contracts/base/CustomChanIbcApp.sol) base contract.
105 | 
106 | Run the following command to go through a full E2E sweep of the project, using the default XCounter.sol contract:
107 | 
108 | ```bash
109 | # Usage: just do-it
110 | just do-it
111 | ```
112 | 
113 | It does the following under the hood:
114 | ```bash
115 | # Run the full E2E flow by setting the contracts, deploying them, creating a channel, and sending a packet
116 | # Usage: just do-it
117 | do-it:
118 |     echo "Running the full E2E flow..."
119 |     just set-contracts optimism XCounter false && just set-contracts base XCounter false
120 |     just deploy optimism base
121 |     just create-channel
122 |     just send-packet optimism
123 |     echo "You've done it!"
124 | ```
125 | 
126 | It makes sure you've got the correct contracts set, deploys new instances, creates a channel and sends a packet over the channel once created.
127 | 
128 | > Note: by default the sim-client is used to improve latency. This is useful for iterative development and testing BUT also insecure as it involves no proofs. Make sure to move to the client **with proofs** by running another just command...
129 | 
130 | ```bash
131 | # Usage: just switch-client
132 | just switch-client
133 | ```
134 | 
135 | Check if the packet got through on the [Polymer IBC explorer](https://sepolia.polymer.zone/packets).
136 | 
137 | 
138 | ## 💻 Develop your custom application
139 | 
140 | The main work for you as a developer is to develop the contracts that make up your cross-chain logic.
141 | 
142 | You can use the contracts in the "/contracts/base" directory as base contracts for creating IBC enabled contracts that can either send packets over the universal channel or create their own channel to send packets over.
143 | 
144 | A complete walkthrough on how to develop these contracts is provided in the [official Polymer documentation](https://docs.polymerlabs.org/docs/build/ibc-solidity/).
145 | 
146 | ## 🕹️ Interaction with the contracts
147 | 
148 | When the contracts are ready, you can go ahead and interact with the contracts through scripts. There is a Justfile to for the most common commands, with the underlying scripts in the /scripts folder.
149 | 
150 | The `/private` folder within the scripts folder has scripts that you're unlikely to need to touch. The only scripts you'll (potentially) be interacting with are:
151 | 
152 | There's three types of default scripts in the project:
153 | 
154 | - The `deploy.js` allows you to deploy your application contract. You may want to add additional deployment logic to the Hardhat script.
155 | - In the `/contracts` folder you'll find `arguments.js` to add your custom constructor arguments for automated deployment with the `deploy.js` script.
156 | - The `send-packet.js` script sends packets over an existing custom channel, and `send-universal-packet.js` is specifically for sending packets over a universal channel. You might want to add additional logic before or after sending the packet to cusotmize your application.
157 | 
158 | For most of the actions above and more, there are just recipes that combine related logic and update the configuation file in an automated way.
159 | 
160 | > **Note**: These are the default scripts provided. They provide the most generic interactions with the contracts to deploy, create channels and send packets. For more complicated use cases you will want to customize the scripts to your use case. See [advanced usage](#🦾-advanced-usage) for more info.
161 | 
162 | ### Deploy
163 | 
164 | Before deploying, make sure to update the config.json with your contract type to deploy for each of the chain you wish to deploy to.
165 | 
166 | #### Set contracts to config
167 | 
168 | Do this by running:
169 | 
170 | ```bash
171 | # Usage: just set-contracts [chain] [contract_type] [universal]
172 | just set-contracts optimism MyContract true
173 | ```
174 | 
175 | to deploy _MyContract_ artefact to the Optimism (Sepolia) chain.
176 | 
177 | > **IMPORTANT**: This is where you set if your contract uses universal or custom channels. Make sure this corresponds to the base contract you've inherited from when developing your application (UniversalChanIbcApp or CustomChanIbcApp).
178 | 
179 | #### Constructor arguments
180 | 
181 | By default any application inheriting a base IBC application contract will need a dispatcher or universal channel handler address passed into the constructor. Obviously you might have other constructor arguments you may want to add. To still make use of the `just deploy source destination` recipe, add your arguments to the arguments.js file
182 | 
183 | ```javascript title="/contracts/arguments.js"
184 | module.exports = {
185 |     "XCounter": [],
186 |     "XCounterUC": [],
187 |     // Add your contract types here, along with the list of custom constructor arguments
188 |     // DO NOT ADD THE DISPATCHER OR UNIVERSAL CHANNEL HANDLER ADDRESSES HERE!!!
189 |     // These will be added in the deploy script at $ROOT/scripts/deploy.js
190 | };
191 | ```
192 | 
193 | #### Finally: deploy
194 | 
195 | Then run:
196 | 
197 | ```bash
198 | # Usage: just deploy [source] [destination]
199 | just deploy optimism base
200 | ```
201 | 
202 | where the script will automatically detect whether you are using custom or universal IBC channels.
203 | 
204 | The script will take the output of the deployment and update the config file with all the relevant information.
205 | 
206 | Before moving on, you'll want to check if the variables in your .env and config files line up with what is stored in the actual deployed contracts... especially when you're actively playing around with different configuration files and contracts.
207 | 
208 | To do a sanity check, run:
209 | ```bash
210 | # Usage: just sanity-check
211 | just sanity-check
212 | ```
213 | 
214 | ### Create a channel
215 | 
216 | If you're **using universal channels, channel creation is not required**. Your contract will send and receive packet data from the Universal channel handler contract which already has a universal channel to send packets over. You can directly proceed to sending (universal) packets in that case.
217 | 
218 | To create a custom channel, run:
219 | 
220 | ```bash
221 | just create-channel
222 | ```
223 | 
224 | This creates a channel between base and optimism. Note that the **ORDER MATTERS**; if you picked optimism as the source chain (first argument) above, by default it will create the channel from optimism and vice versa.
225 | 
226 | The script will take the output of the channel creation and update the config file with all the relevant information.
227 | 
228 | Check out the [channel tab in the explorer](https://sepolia.polymer.zone/channels) to find out if the correct channel-id's related to your contracts were updated in the config.
229 | 
230 | ### Send packets
231 | 
232 | Finally Run:
233 | 
234 | ```bash
235 | # Usage: just send-packet
236 | just send-packet optimism 
237 | ```
238 | 
239 | to send a packet over a channel (script looks at the config's isUniversal flag to know if it should use the custom or universal packet). You can pick either optimism or base to send the packet from.
240 | 
241 | ## Verify, don't trust
242 | 
243 | As a starter value, the sim-client is used to improve latency. **The sim-client is useful for iterative development and testing BUT also insecure as it involves no proofs**. Make sure to move to the client **with proofs** by running another just command...
244 | 
245 | ```bash
246 | # Usage: just switch-client
247 | just switch-client
248 | ```
249 | 
250 | This will use the op-stack client with proofs, making sure that the relayer is proving what is being submitted every step along the way, ensuring there's no trust assumption on the relayer.
251 | 
252 | An overview of the different clients can be found in `ibc.json`:
253 | ```json
254 | {
255 |     "optimism": {
256 |         "sim-client": {
257 |             "canonConnFrom": "connection-0",
258 |             "canonConnTo": "connection-1",
259 |             "universalChannel": "channel-10"
260 |         },
261 |         "op-client": {
262 |             "canonConnFrom": "connection-8",
263 |             "canonConnTo": "connection-9",
264 |             "universalChannel": "channel-16"
265 |         }
266 |     },
267 |     "base": {
268 |         "sim-client" : {
269 |             "canonConnFrom": "connection-4",
270 |             "canonConnTo": "connection-5",
271 |             "universalChannel": "channel-11"
272 |         },
273 |         "op-client": {
274 |             "canonConnFrom": "connection-10",
275 |             "canonConnTo": "connection-11",
276 |             "universalChannel": "channel-17"
277 |         }
278 |     }
279 | }
280 | ```
281 | 
282 | ## 🦾 Advanced usage
283 | 
284 | For advanced users, there's multiple custimizations to follow. These includes configuring the config.json manually and/or running the scripts without using just.
285 | 
286 | For example, the last action to send a packet on a universal channel could be executed with this command:
287 | 
288 | ```bash
289 | npx hardhat run scripts/send-universal-packet.js --network base
290 | ```
291 | 
292 | To send a universal packet from the contract specified in the config.sendUniversalPacket field in the config.
293 | 
294 | ## 🤝 Contributing
295 | 
296 | We welcome and encourage contributions from our community! Here’s how you can contribute.
297 | 
298 | Take a look at the open issues. If there's an issue that has the _help wanted_ label or _good first issue_, those are up for grabs. Assign yourself to the issue so people know you're working on it.
299 | 
300 | Alternatively you can open an issue for a new idea or piece of feedback.
301 | 
302 | When you want to contribute code, please follow these steps:
303 | 
304 | 1. **Fork the Repository:** Start by forking this repository.
305 | 2. **Apply the improvements:** Want to optimize something or add support for additional developer tooling? Add your changes!
306 | 3. **Create a Pull Request:** Once you're ready and have tested your added code, submit a PR to the repo and we'll review as soon as possible.
307 | 
308 | ## 💡 Questions or Suggestions?
309 | 
310 | Feel free to open an issue for questions, suggestions, or discussions related to this repository. For further discussion as well as a showcase of some community projects, check out the [Polymer developer forum](https://forum.polymerlabs.org).
311 | 
312 | Thank you for being a part of our community!
313 | 


--------------------------------------------------------------------------------