powerdlz23 1.1.4 → 1.1.6

package/polymer/polymer-template/contracts/XCounterUC.sol

@@ -0,0 +1,100 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.9;
+
+import "./base/UniversalChanIbcApp.sol";
+
+contract XCounterUC is UniversalChanIbcApp {
+    // application specific state
+    uint64 public counter;
+    mapping(uint64 => address) public counterMap;
+
+    constructor(address _middleware) UniversalChanIbcApp(_middleware) {}
+
+    // application specific logic
+    function resetCounter() internal {
+        counter = 0;
+    }
+
+    function increment() internal {
+        counter++;
+    }
+
+    // IBC logic
+
+    /**
+     * @dev Sends a packet with the caller's address over the universal channel.
+     * @param destPortAddr The address of the destination application.
+     * @param channelId The ID of the channel to send the packet to.
+     * @param timeoutSeconds The timeout in seconds (relative).
+     */
+    function sendUniversalPacket(address destPortAddr, bytes32 channelId, uint64 timeoutSeconds) external {
+        increment();
+        bytes memory payload = abi.encode(msg.sender, counter);
+
+        uint64 timeoutTimestamp = uint64((block.timestamp + timeoutSeconds) * 1000000000);
+
+        IbcUniversalPacketSender(mw).sendUniversalPacket(
+            channelId, IbcUtils.toBytes32(destPortAddr), payload, timeoutTimestamp
+        );
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
+     *      MUST be overriden by the inheriting contract.
+     *
+     * @param channelId the ID of the channel (locally) the packet was received on.
+     * @param packet the Universal packet encoded by the source and relayed by the relayer.
+     */
+    function onRecvUniversalPacket(bytes32 channelId, UniversalPacket calldata packet)
+        external
+        override
+        onlyIbcMw
+        returns (AckPacket memory ackPacket)
+    {
+        recvedPackets.push(UcPacketWithChannel(channelId, packet));
+
+        (address payload, uint64 c) = abi.decode(packet.appData, (address, uint64));
+        counterMap[c] = payload;
+
+        increment();
+
+        return AckPacket(true, abi.encode(counter));
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet acknowledgment logic.
+     *      MUST be overriden by the inheriting contract.
+     *
+     * @param channelId the ID of the channel (locally) the ack was received on.
+     * @param packet the Universal packet encoded by the source and relayed by the relayer.
+     * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
+     */
+    function onUniversalAcknowledgement(bytes32 channelId, UniversalPacket memory packet, AckPacket calldata ack)
+        external
+        override
+        onlyIbcMw
+    {
+        ackPackets.push(UcAckWithChannel(channelId, packet, ack));
+
+        // decode the counter from the ack packet
+        (uint64 _counter) = abi.decode(ack.data, (uint64));
+
+        if (_counter != counter) {
+            resetCounter();
+        }
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
+     *      MUST be overriden by the inheriting contract.
+     *      NOT SUPPORTED YET
+     *
+     * @param channelId the ID of the channel (locally) the timeout was submitted on.
+     * @param packet the Universal packet encoded by the counterparty and relayed by the relayer
+     */
+    function onTimeoutUniversalPacket(bytes32 channelId, UniversalPacket calldata packet) external override onlyIbcMw {
+        timeoutPackets.push(UcPacketWithChannel(channelId, packet));
+        // do logic
+    }
+}

package/polymer/polymer-template/contracts/arguments.js

@@ -0,0 +1,7 @@
+module.exports = {
+    "XCounter": [],
+    "XCounterUC": [],
+    // Add your contract types here, along with the list of custom constructor arguments
+    // DO NOT ADD THE DISPATCHER OR UNIVERSAL CHANNEL HANDLER ADDRESSES HERE!!!
+    // These will be added in the deploy script at $ROOT/scripts/deploy.js
+};

package/polymer/polymer-template/contracts/base/CustomChanIbcApp.sol

@@ -0,0 +1,205 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.9;
+
+import '@open-ibc/vibc-core-smart-contracts/contracts/libs/Ibc.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcReceiver.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcDispatcher.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/ProofVerifier.sol';
+
+// CustomChanIbcApp is a contract that can be used as a base contract
+// for IBC-enabled contracts that send packets over a custom IBC channel.
+contract CustomChanIbcApp is IbcReceiverBase, IbcReceiver {
+    // received packet as chain B
+    IbcPacket[] public recvedPackets;
+    // received ack packet as chain A
+    AckPacket[] public ackPackets;
+    // received timeout packet as chain A
+    IbcPacket[] public timeoutPackets;
+    
+    struct ChannelMapping {
+        bytes32 channelId;
+        bytes32 cpChannelId;
+    }
+    
+    // ChannelMapping array with the channel IDs of the connected channels
+    ChannelMapping[] public connectedChannels;
+
+    // add supported versions (format to be negotiated between apps)
+    string[] supportedVersions = ['1.0'];
+
+    constructor(IbcDispatcher _dispatcher) IbcReceiverBase(_dispatcher) {}
+
+    function updateDispatcher(IbcDispatcher _dispatcher) external onlyOwner {
+        dispatcher = _dispatcher;
+    }
+
+    function getConnectedChannels() external view returns (ChannelMapping[] memory) {
+        return connectedChannels;
+    }
+
+    function updateSupportedVersions(string[] memory _supportedVersions) external onlyOwner {
+        supportedVersions = _supportedVersions;
+    }
+
+    /** 
+     * @dev Implement a function to send a packet that calls the dispatcher.sendPacket function
+     *      It has the following function handle:
+     *          function sendPacket(bytes32 channelId, bytes calldata payload, uint64 timeoutTimestamp) external;
+     */
+
+    /**
+     * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
+     *      MUST be overriden by the inheriting contract.
+     * 
+     * @param packet the IBC packet encoded by the source and relayed by the relayer.
+     */
+    function onRecvPacket(IbcPacket memory packet) external virtual onlyIbcDispatcher returns (AckPacket memory ackPacket) {
+        recvedPackets.push(packet);
+        // do logic
+        return AckPacket(true, abi.encodePacked('{ "account": "account", "reply": "got the message" }'));
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet acknowledgment logic.
+     *      MUST be overriden by the inheriting contract.
+     * 
+     * @param packet the IBC packet encoded by the source and relayed by the relayer.
+     * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
+     */
+    function onAcknowledgementPacket(IbcPacket calldata packet, AckPacket calldata ack) external virtual onlyIbcDispatcher {
+        ackPackets.push(ack);
+        // do logic
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
+     *      MUST be overriden by the inheriting contract.
+     *      NOT SUPPORTED YET
+     * 
+     * @param packet the IBC packet encoded by the counterparty and relayed by the relayer
+     */
+    function onTimeoutPacket(IbcPacket calldata packet) external virtual onlyIbcDispatcher {
+        timeoutPackets.push(packet);
+        // do logic
+    }
+
+    /**
+     * @dev Create a custom channel between two IbcReceiver contracts
+     * @param local a CounterParty struct with the local chain's portId and version (channelId can be empty)
+     * @param ordering the channel ordering (NONE, UNORDERED, ORDERED) equivalent to (0, 1, 2)
+     * @param feeEnabled in production, you'll want to enable this to avoid spamming create channel calls (costly for relayers)
+     * @param connectionHops 2 connection hops to connect to the destination via Polymer
+     * @param counterparty the address of the destination chain contract you want to connect to
+     * @param proof ICS23 proof struct with dummy data (only needed on ChanOpenTry)
+     */
+    function createChannel(
+        CounterParty calldata local,
+        uint8 ordering,
+        bool feeEnabled, 
+        string[] calldata connectionHops, 
+        CounterParty calldata counterparty, 
+        Ics23Proof calldata proof
+        ) external virtual onlyOwner{
+
+        dispatcher.openIbcChannel(
+            IbcChannelReceiver(address(this)),
+            local,
+            ChannelOrder(ordering),
+            feeEnabled,
+            connectionHops,
+            counterparty,
+            proof
+        );
+    }
+
+    function onOpenIbcChannel(
+        string calldata version,
+        ChannelOrder,
+        bool,
+        string[] calldata,
+        CounterParty calldata counterparty
+    ) external view virtual onlyIbcDispatcher returns (string memory selectedVersion) {
+        if (bytes(counterparty.portId).length <= 8) {
+            revert invalidCounterPartyPortId();
+        }
+        /**
+         * Version selection is determined by if the callback is invoked on behalf of ChanOpenInit or ChanOpenTry.
+         * ChanOpenInit: self version should be provided whereas the counterparty version is empty.
+         * ChanOpenTry: counterparty version should be provided whereas the self version is empty.
+         * In both cases, the selected version should be in the supported versions list.
+         */
+        bool foundVersion = false;
+        selectedVersion = keccak256(abi.encodePacked(version)) == keccak256(abi.encodePacked(''))
+            ? counterparty.version
+            : version;
+        for (uint256 i = 0; i < supportedVersions.length; i++) {
+            if (keccak256(abi.encodePacked(selectedVersion)) == keccak256(abi.encodePacked(supportedVersions[i]))) {
+                foundVersion = true;
+                break;
+            }
+        }
+        require(foundVersion, 'Unsupported version');
+        // if counterpartyVersion is not empty, then it must be the same foundVersion
+        if (keccak256(abi.encodePacked(counterparty.version)) != keccak256(abi.encodePacked(''))) {
+            require(
+                keccak256(abi.encodePacked(counterparty.version)) == keccak256(abi.encodePacked(selectedVersion)),
+                'Version mismatch'
+            );
+        }
+
+        // do logic
+
+        return selectedVersion;
+    }
+
+    function onConnectIbcChannel(
+        bytes32 channelId,
+        bytes32 counterpartyChannelId,
+        string calldata counterpartyVersion
+    ) external virtual onlyIbcDispatcher {
+        // ensure negotiated version is supported
+        bool foundVersion = false;
+        for (uint256 i = 0; i < supportedVersions.length; i++) {
+            if (keccak256(abi.encodePacked(counterpartyVersion)) == keccak256(abi.encodePacked(supportedVersions[i]))) {
+                foundVersion = true;
+                break;
+            }
+        }
+        require(foundVersion, 'Unsupported version');
+
+        // do logic
+
+        ChannelMapping memory channelMapping = ChannelMapping({
+            channelId: channelId,
+            cpChannelId: counterpartyChannelId
+        });
+        connectedChannels.push(channelMapping);
+    }
+
+    function onCloseIbcChannel(bytes32 channelId, string calldata, bytes32) external virtual onlyIbcDispatcher {
+        // logic to determin if the channel should be closed
+        bool channelFound = false;
+        for (uint256 i = 0; i < connectedChannels.length; i++) {
+            if (connectedChannels[i].channelId == channelId) {
+                for (uint256 j = i; j < connectedChannels.length - 1; j++) {
+                    connectedChannels[j] = connectedChannels[j + 1];
+                }
+                connectedChannels.pop();
+                channelFound = true;
+                break;
+            }
+        }
+        require(channelFound, 'Channel not found');
+
+        // do logic
+    }
+
+    /**
+     * This func triggers channel closure from the dApp.
+     * Func args can be arbitary, as long as dispatcher.closeIbcChannel is invoked propperly.
+     */
+    function triggerChannelClose(bytes32 channelId) external virtual onlyOwner {
+        dispatcher.closeIbcChannel(channelId);
+    }
+}

package/polymer/polymer-template/contracts/base/GeneralMiddleware.sol

@@ -0,0 +1,200 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.9;
+
+import '@open-ibc/vibc-core-smart-contracts/contracts/libs/Ibc.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcReceiver.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcDispatcher.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcMiddleware.sol';
+
+contract GeneralMiddleware is IbcMwUser, IbcMiddleware, IbcMwEventsEmitter {
+    /**
+     * @dev MW_ID is the ID of MW contract on all supported virtual chains.
+     * MW_ID must:
+     * - be globally unique, ie. no two MWs should have the same MW_ID registered on Polymer chain.
+     * - be identical on all supported virtual chains.
+     * - be identical on one virtual chain across multiple deployed MW instances. Each MW instance belong exclusively to one MW stack.
+     * - be 1 << N, where N is a non-negative integer, and not in conflict with other MWs.
+     */
+    uint256 public MW_ID;
+
+    /**
+     * @param _middleware The middleware contract address this contract sends packets to and receives packets from.
+     */
+
+    constructor(uint256 mwId, address _middleware) IbcMwUser(_middleware) {
+        MW_ID = mwId;
+    }
+
+    function sendUniversalPacket(
+        bytes32 channelId,
+        bytes32 destPortAddr,
+        bytes calldata appData,
+        uint64 timeoutTimestamp
+    ) external override {
+        _sendPacket(channelId, IbcUtils.toBytes32(msg.sender), destPortAddr, 0, appData, timeoutTimestamp);
+    }
+
+    function sendMWPacket(
+        bytes32 channelId,
+        bytes32 srcPortAddr,
+        bytes32 destPortAddr,
+        uint256 srcMwIds,
+        bytes calldata appData,
+        uint64 timeoutTimestamp
+    ) external override {
+        _sendPacket(channelId, srcPortAddr, destPortAddr, srcMwIds, appData, timeoutTimestamp);
+    }
+
+    function onRecvMWPacket(
+        bytes32 channelId,
+        UniversalPacket calldata ucPacket,
+        // address srcPortAddr,
+        // address destPortAddr,
+        // 0-based receiver middleware index in the MW stack.
+        //  0 for the first MW directly called by UniversalChannel MW.
+        // `mwIndex-1` is the last MW that delivers the packet to the non-MW dApp.
+        // Each mw in the stack must increment mwIndex by 1 before calling the next MW.
+        uint256 mwIndex,
+        // bytes calldata appData,
+        address[] calldata mwAddrs
+    ) external onlyIbcMw returns (AckPacket memory ackPacket) {
+        // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
+        // implementer can emit custom data fields suitable for their use cases.
+        // Here we use MW_ID as the custom MW data field.
+        emit RecvMWPacket(
+            channelId,
+            ucPacket.srcPortAddr,
+            ucPacket.destPortAddr,
+            MW_ID,
+            ucPacket.appData,
+            abi.encodePacked(MW_ID)
+        );
+
+        if (mwIndex == mwAddrs.length - 1) {
+            // last MW in the stack, deliver packet to dApp
+            return
+                IbcUniversalPacketReceiver(IbcUtils.toAddress(ucPacket.destPortAddr)).onRecvUniversalPacket(
+                    channelId,
+                    ucPacket
+                );
+        } else {
+            // send packet to next MW
+            return IbcMwPacketReceiver(mwAddrs[mwIndex + 1]).onRecvMWPacket(channelId, ucPacket, mwIndex + 1, mwAddrs);
+        }
+    }
+
+    function onRecvMWAck(
+        bytes32 channelId,
+        UniversalPacket calldata ucPacket,
+        // 0-based receiver middleware index in the MW stack.
+        //  0 for the first MW directly called by UniversalChannel MW.
+        // `mwIndex-1` is the last MW that delivers the packet to the non-MW dApp.
+        // Each mw in the stack must increment mwIndex by 1 before calling the next MW.
+        uint256 mwIndex,
+        address[] calldata mwAddrs,
+        AckPacket calldata ack
+    ) external override onlyIbcMw {
+        // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
+        // implementer can emit custom data fields suitable for their use cases.
+        // Here we use MW_ID as the custom MW data field.
+        emit RecvMWAck(
+            channelId,
+            ucPacket.srcPortAddr,
+            ucPacket.destPortAddr,
+            MW_ID,
+            ucPacket.appData,
+            abi.encodePacked(MW_ID),
+            ack
+        );
+
+        if (mwIndex == mwAddrs.length - 1) {
+            // last MW in the stack, deliver ack to dApp
+            IbcUniversalPacketReceiver(IbcUtils.toAddress(ucPacket.srcPortAddr)).onUniversalAcknowledgement(
+                channelId,
+                ucPacket,
+                ack
+            );
+        } else {
+            // send ack to next MW
+            IbcMwPacketReceiver(mwAddrs[mwIndex + 1]).onRecvMWAck(channelId, ucPacket, mwIndex + 1, mwAddrs, ack);
+        }
+    }
+
+    function onRecvMWTimeout(
+        bytes32 channelId,
+        UniversalPacket calldata ucPacket,
+        uint256 mwIndex,
+        address[] calldata mwAddrs
+    ) external override onlyIbcMw {
+        // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
+        // implementer can emit custom data fields suitable for their use cases.
+        // Here we use MW_ID as the custom MW data field.
+        emit RecvMWTimeout(
+            channelId,
+            ucPacket.srcPortAddr,
+            ucPacket.destPortAddr,
+            MW_ID,
+            ucPacket.appData,
+            abi.encodePacked(MW_ID)
+        );
+
+        if (mwIndex == mwAddrs.length - 1) {
+            // last MW in the stack, deliver timeout to dApp
+            IbcUniversalPacketReceiver(IbcUtils.toAddress(ucPacket.srcPortAddr)).onTimeoutUniversalPacket(
+                channelId,
+                ucPacket
+            );
+        } else {
+            // send timeout to next MW
+            IbcMwPacketReceiver(mwAddrs[mwIndex + 1]).onRecvMWTimeout(channelId, ucPacket, mwIndex + 1, mwAddrs);
+        }
+    }
+
+    function onRecvUniversalPacket(
+        bytes32 channelId,
+        UniversalPacket calldata ucPacket
+    ) external override onlyIbcMw returns (AckPacket memory ackPacket) {}
+
+    function onUniversalAcknowledgement(
+        bytes32 channelId,
+        UniversalPacket memory packet,
+        AckPacket calldata ack
+    ) external override onlyIbcMw {}
+
+    function onTimeoutUniversalPacket(bytes32 channelId, UniversalPacket calldata packet) external override onlyIbcMw {}
+
+    // internal function to send packet to next MW with MW Ids bit flipped
+    // param srcMwIds: MW ID bitmap excluding this MW's ID
+    function _sendPacket(
+        bytes32 channelId,
+        bytes32 srcPortAddr,
+        bytes32 destPortAddr,
+        uint256 srcMwIds,
+        bytes calldata appData,
+        uint64 timeoutTimestamp
+    ) internal virtual {
+        // extra MW custom logic here to process packet, eg. emit MW events, mutate state, etc.
+        // implementer can emit custom data fields suitable for their use cases.
+        // Here we use MW_ID as the custom MW data field.
+        emit SendMWPacket(
+            channelId,
+            srcPortAddr,
+            destPortAddr,
+            MW_ID,
+            appData,
+            timeoutTimestamp,
+            abi.encodePacked(MW_ID)
+        );
+
+        // send packet to next MW
+        IbcMwPacketSender(mw).sendMWPacket(
+            channelId,
+            srcPortAddr,
+            destPortAddr,
+            srcMwIds | MW_ID,
+            appData,
+            timeoutTimestamp
+        );
+    }
+}

package/polymer/polymer-template/contracts/base/UniversalChanIbcApp.sol

@@ -0,0 +1,93 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.9;
+
+import '@open-ibc/vibc-core-smart-contracts/contracts/libs/Ibc.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcReceiver.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcDispatcher.sol';
+import '@open-ibc/vibc-core-smart-contracts/contracts/interfaces/IbcMiddleware.sol';
+
+// UniversalChanIbcApp is a contract that can be used as a base contract 
+// for IBC-enabled contracts that send packets over the universal channel.
+contract UniversalChanIbcApp is IbcMwUser, IbcUniversalPacketReceiver {
+    struct UcPacketWithChannel {
+        bytes32 channelId;
+        UniversalPacket packet;
+    }
+
+    struct UcAckWithChannel {
+        bytes32 channelId;
+        UniversalPacket packet;
+        AckPacket ack;
+    }
+
+    // received packet as chain B
+    UcPacketWithChannel[] public recvedPackets;
+    // received ack packet as chain A
+    UcAckWithChannel[] public ackPackets;
+    // received timeout packet as chain A
+    UcPacketWithChannel[] public timeoutPackets;
+
+    constructor(address _middleware) IbcMwUser(_middleware) {}
+
+    /** 
+     * @dev Implement a function to send a packet that calls the IbcUniversalPacketSender(mw).sendUniversalPacket function
+     *      It has the following function handle:
+     *          function sendUniversalPacket(
+                    bytes32 channelId,
+                    bytes32 destPortAddr,
+                    bytes calldata appData,
+                    uint64 timeoutTimestamp
+                ) external;
+     */
+
+    /**
+     * @dev Packet lifecycle callback that implements packet receipt logic and returns and acknowledgement packet.
+     *      MUST be overriden by the inheriting contract.
+     * 
+     * @param channelId the ID of the channel (locally) the packet was received on.
+     * @param packet the Universal packet encoded by the source and relayed by the relayer.
+     */
+    function onRecvUniversalPacket(
+        bytes32 channelId,
+        UniversalPacket calldata packet
+    ) external virtual onlyIbcMw returns (AckPacket memory ackPacket) {
+        recvedPackets.push(UcPacketWithChannel(channelId, packet));
+        // 1. decode the packet.data
+        // 2. do logic
+        // 3. encode the ack packet (encoding format should be agreed between the two applications)
+        // below is an example, the actual ackpacket data should be implemented by the contract developer
+        return AckPacket(true, abi.encodePacked(address(this), IbcUtils.toAddress(packet.srcPortAddr), 'ack-', packet.appData));
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet acknowledgment logic.
+     *      MUST be overriden by the inheriting contract.
+     * 
+     * @param channelId the ID of the channel (locally) the ack was received on.
+     * @param packet the Universal packet encoded by the source and relayed by the relayer.
+     * @param ack the acknowledgment packet encoded by the destination and relayed by the relayer.
+     */
+    function onUniversalAcknowledgement(
+        bytes32 channelId,
+        UniversalPacket memory packet,
+        AckPacket calldata ack
+    ) external virtual onlyIbcMw {
+        ackPackets.push(UcAckWithChannel(channelId, packet, ack));
+        // 1. decode the ack.data
+        // 2. do logic
+    }
+
+    /**
+     * @dev Packet lifecycle callback that implements packet receipt logic and return and acknowledgement packet.
+     *      MUST be overriden by the inheriting contract.
+     *      NOT SUPPORTED YET
+     * 
+     * @param channelId the ID of the channel (locally) the timeout was submitted on.
+     * @param packet the Universal packet encoded by the counterparty and relayed by the relayer
+     */
+    function onTimeoutUniversalPacket(bytes32 channelId, UniversalPacket calldata packet) external virtual onlyIbcMw {
+        timeoutPackets.push(UcPacketWithChannel(channelId, packet));
+        // do logic
+    }
+}

package/polymer/polymer-template/foundry.toml

@@ -0,0 +1,6 @@
+[profile.default]
+src = 'contracts'
+out = 'out'
+libs = ['node_modules', 'lib']
+test = 'test'
+cache_path  = 'cache_forge'

package/polymer/polymer-template/hardhat.config.js

@@ -0,0 +1,66 @@
+require("@nomicfoundation/hardhat-toolbox");
+require("@nomicfoundation/hardhat-foundry");
+
+require('dotenv').config();
+
+/** @type import('hardhat/config').HardhatUserConfig */
+module.exports = {
+  solidity: {
+    version: '0.8.23',
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 200 // Optimize for a typical number of runs
+      }
+    }    
+  },
+  networks: {
+    // for Base testnet
+    'base': {
+      url: 'https://sepolia.base.org',
+      accounts: [
+        process.env.PRIVATE_KEY_1
+      ],
+    },
+    // for OP testnet
+    'optimism': {
+      url: 'https://sepolia.optimism.io',
+      accounts: [
+        process.env.PRIVATE_KEY_1
+      ],
+    },    
+  },
+  defaultNetwork: 'optimism',
+  paths: {
+    sources: './contracts',
+    tests: './test',
+    cache: './cache',
+    artifacts: './artifacts',
+    libraries: './lib',
+  },
+  etherscan: {
+    apiKey: {
+      optimism: process.env.OP_BLOCKSCOUT_API_KEY,
+      base: process.env.BASE_BLOCKSCOUT_API_KEY,
+    },
+    customChains: [
+      {
+        network: "base",
+        chainId: 84532,
+        urls: {
+          apiURL: "https://base-sepolia.blockscout.com/api",
+          browserURL: "https://base-sepolia.blockscout.com",
+        }
+      },
+      {
+        network: "optimism",
+        chainId: 11155420,
+        urls: {
+          apiURL: "https://optimism-sepolia.blockscout.com/api",
+          browserURL: "https://optimism-sepolia.blockscout.com",
+        }
+      }
+    ]
+  },
+};
+