@he1sen/hashi 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/pages/api-reference/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+```
+
+Build
+```bash
+npm run build
+```
+
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+## Sync frontend bridge routes
+
+```bash
+npm run gen:routes
+```

package/contracts/src/HashiLightbulb.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+/**
+ *  @authors: [@mani99brar]
+ *  @reviewers: []
+ *  @auditors: []
+ *  @bounties: []
+ *  @deployments: []
+ */
+pragma solidity ^0.8.18;
+
+/**
+ * @title Lightbulb
+ * @dev A lightbulb controlled by a cross-chain switch connected with the Vea bridge.
+ *
+ */
+contract Lightbulb {
+    event LightBulbTurnedOn(address indexed lightBulbOwner, uint256 indexed messageId);
+
+    address owner;
+    address public yaru;
+    uint256 public SOURCE_CHAIN_ID = 421614;
+    address public lightBulbSwitch; // The switch on arbitrum that controls this lightbulb.
+    mapping(address => bool) public lightBulbIsOn;
+    bool switchOn = true;
+
+    modifier onlyOwner() {
+        require(msg.sender == owner);
+        _;
+    }
+
+    constructor(address _owner, address _yaru, address _lightBulbSwitch) {
+        owner = _owner;
+        yaru = _yaru;
+        lightBulbSwitch = _lightBulbSwitch;
+    }
+
+    function flipSwitch(bool _switchOn) external onlyOwner {
+        switchOn = _switchOn;
+    }
+
+    /// @dev Function that gets triggered when the message is relayed, called by Yaru contract
+    /// @param chainId chainId of the chain where message is sending from
+    /// @param sender sender contract
+    /// @param threshold threshold of the message that should be met by adapters
+    /// @param adapters an array of adapters to check the threshold with
+    /// @param data abi-encoded message
+    /// @return
+    function onMessage(
+        uint256 messageId,
+        uint256 chainId,
+        address sender,
+        uint256 threshold,
+        address[] memory adapters,
+        bytes memory data
+    ) external returns (bytes memory) {
+        require(msg.sender == yaru, "only called by Yaru");
+        require(chainId == SOURCE_CHAIN_ID, "invalid source chain ID");
+        require(sender == lightBulbSwitch, "invalid sender address from source chain");
+
+        // Decode the message and store it
+        (address lightBulbOwner) = abi.decode(data, (address));
+        lightBulbIsOn[lightBulbOwner] = true;
+
+        emit LightBulbTurnedOn(lightBulbOwner, messageId);
+        return "";
+    }
+
+    function offBulb() external {
+        lightBulbIsOn[msg.sender] = false;
+    }
+}

package/contracts/src/HashiSwitch.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+
+/**
+ *  @authors: [@mani99brar]
+ *  @reviewers: []
+ *  @auditors: []
+ *  @bounties: []
+ *  @deployments: []
+ */
+pragma solidity ^0.8.18;
+
+import "@hashi/interfaces/IYaho.sol";
+
+/**
+ * @title Lightbulb
+ * @dev A switch on arbitrum turning a light on and off on arbitrum with the Vea bridge.
+ */
+contract Switch {
+    IYaho public yaho;
+
+    constructor(address _yaho){
+        yaho = IYaho(_yaho);
+    }
+    uint256 messageIndex;
+    /**
+     * @dev The Fast Bridge participants watch for these events to decide if a challenge should be submitted.
+     * @param messageId The id of the message sent to the lightbulb.
+     * @param lightBulbOwner The address of the owner of the lightbulb on the L2 side.
+     */
+
+    event LightBulbToggled(uint256 indexed messageId, address indexed lightBulbOwner);
+
+    function turnOnLightBulb(
+        uint32 _lightBulbChainId,
+        address _targetAddress,
+        uint256 _threshold,
+        IReporter[] memory _reporters,
+        IAdapter[] memory _adapters
+    ) external payable {
+        bytes memory _msgData = abi.encode(msg.sender);
+
+        (uint256 msgId,) = yaho.dispatchMessageToAdapters(
+            _lightBulbChainId, _threshold, _targetAddress, _msgData, _reporters, _adapters
+        );
+        emit LightBulbToggled(msgId, msg.sender);
+    }
+}

package/contracts/src/chainlink/CCIPAdapter.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {CCIPReceiver} from "@chainlink/applications/CCIPReceiver.sol";
+import {Client} from "@chainlink/libraries/Client.sol";
+import {Adapter} from "@hashi/adapters/Adapter.sol";
+
+contract CCIPAdapter is Adapter, Ownable, CCIPReceiver {
+    string public constant PROVIDER = "ccip";
+
+    mapping(uint64 => address) public enabledReporters;
+    mapping(uint64 => uint256) public chainIds;
+
+    error UnauthorizedCCIPReceive();
+
+    event ReporterSet(uint256 indexed chainId, uint64 indexed chainSelector, address indexed reporter);
+
+    constructor(address ccipRouter) CCIPReceiver(ccipRouter) {} // solhint-disable no-empty-blocks
+
+    function setReporterByChain(uint256 chainId, uint64 chainSelector, address reporter) external onlyOwner {
+        enabledReporters[chainSelector] = reporter;
+        chainIds[chainSelector] = chainId;
+        emit ReporterSet(chainId, chainSelector, reporter);
+    }
+
+    function _ccipReceive(Client.Any2EVMMessage memory message) internal override {
+        // NOTE: validity of `msg.sender` is ensured by `CCIPReceiver` prior this internal function invocation
+        address sender = abi.decode(message.sender, (address));
+        if (enabledReporters[message.sourceChainSelector] != sender) revert UnauthorizedCCIPReceive();
+        uint256 sourceChainId = chainIds[message.sourceChainSelector];
+        (uint256[] memory ids, bytes32[] memory hashes) = abi.decode(message.data, (uint256[], bytes32[]));
+        _storeHashes(sourceChainId, ids, hashes);
+    }
+}

package/contracts/src/chainlink/CCIPReporter.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IRouterClient} from "@chainlink/interfaces/IRouterClient.sol";
+import {Client} from "@chainlink/libraries/Client.sol";
+import {Reporter} from "@hashi/adapters/Reporter.sol";
+
+contract CCIPReporter is Reporter, Ownable {
+    string public constant PROVIDER = "ccip";
+
+    IRouterClient public immutable CCIP_ROUTER;
+
+    uint256 public fee;
+    mapping(uint256 => uint64) public chainSelectors;
+
+    error ChainSelectorNotAvailable();
+
+    event ChainSelectorSet(uint256 indexed chainId, uint64 indexed chainSelector);
+    event FeeSet(uint256 fee);
+
+    constructor(address headerStorage, address yaho, address ccipRouter) Reporter(headerStorage, yaho) {
+        CCIP_ROUTER = IRouterClient(ccipRouter);
+    }
+
+    function setChainSelectorByChainId(uint256 chainId, uint64 chainSelector) external onlyOwner {
+        chainSelectors[chainId] = chainSelector;
+        emit ChainSelectorSet(chainId, chainSelector);
+    }
+
+    function setFee(uint256 fee_) external onlyOwner {
+        fee = fee_;
+        emit FeeSet(fee_);
+    }
+
+    function _dispatch(uint256 targetChainId, address adapter, uint256[] memory ids, bytes32[] memory hashes)
+        internal
+        override
+        returns (bytes32)
+    {
+        uint64 targetChainSelector = chainSelectors[targetChainId];
+        if (targetChainSelector == 0) revert ChainSelectorNotAvailable();
+        bytes memory payload = abi.encode(ids, hashes);
+        Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
+            receiver: abi.encode(adapter),
+            data: payload,
+            tokenAmounts: new Client.EVMTokenAmount[](0), // Empty array - no tokens are transferred
+            extraArgs: Client._argsToBytes(Client.EVMExtraArgsV1({gasLimit: 200_000, strict: false})),
+            feeToken: address(0) // Pay fees with native
+        });
+
+        uint256 fees = CCIP_ROUTER.getFee(targetChainSelector, message);
+
+        require(fees < address(this).balance, "Insufficient fee provided");
+        CCIP_ROUTER.ccipSend{value: fees}(targetChainSelector, message);
+        return bytes32(0);
+    }
+
+    receive() external payable {}
+}

package/contracts/src/vea/VeaAdapter.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+import {Adapter} from "@hashi/adapters/Adapter.sol";
+import {IReceiverGateway} from "./interfaces/IReceiverGateway.sol";
+
+contract VeaAdapter is IReceiverGateway, Adapter {
+    string public constant PROVIDER = "vea";
+
+    address public immutable VEA_OUTBOX;
+    address public REPORTER;
+    uint256 public immutable SOURCE_CHAIN_ID;
+
+    error ArrayLengthMissmatch();
+    error InvalidVeaOutbox(address veaOutbox, address expectedVeaOutboux);
+    error InvalidReporter(address reporter, address expectedReporter);
+
+    constructor(address veaOutbox_, uint256 sourceChainId) {
+        VEA_OUTBOX = veaOutbox_;
+        SOURCE_CHAIN_ID = sourceChainId;
+    }
+
+    modifier onlyFromAuthenticatedVeaSender(address sourceMsgSender) {
+        if (msg.sender != VEA_OUTBOX) revert InvalidVeaOutbox(msg.sender, VEA_OUTBOX);
+        if (sourceMsgSender != REPORTER) revert InvalidReporter(REPORTER, sourceMsgSender);
+        _;
+    }
+
+    function setReporter(address reporter) external {
+        REPORTER = reporter;
+    }
+
+    function senderGateway() external view override returns (address) {
+        return REPORTER;
+    }
+
+    function veaOutbox() external view override returns (address) {
+        return VEA_OUTBOX;
+    }
+
+    function receiveMessage(address sourceMsgSender, bytes calldata data)
+        external
+        override
+        onlyFromAuthenticatedVeaSender(sourceMsgSender)
+    {
+        (uint256[] memory ids, bytes32[] memory hashes) = abi.decode(data, (uint256[], bytes32[]));
+        _storeHashes(SOURCE_CHAIN_ID, ids, hashes);
+    }
+}

package/contracts/src/vea/VeaReporter.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+import {VeaAdapter} from "./VeaAdapter.sol";
+import {Reporter} from "@hashi/adapters/Reporter.sol";
+import {ISenderGateway} from "./interfaces/ISenderGateway.sol";
+import {IVeaInbox} from "./interfaces/IVeaInbox.sol";
+
+contract VeaReporter is ISenderGateway, Reporter {
+    string public constant PROVIDER = "vea";
+
+    IVeaInbox public immutable VEA_INBOX;
+    address public immutable ADAPTER;
+    uint256 public immutable EXPECTED_TARGET_CHAIN_ID;
+
+    error InvalidAdapter(address adapter, address expectedAdapter);
+    error InvalidTargetChainId(uint256 targetChainId, uint256 expectedTargetChainId);
+
+    constructor(
+        address headerStorage,
+        address yaho,
+        IVeaInbox veaInbox_,
+        address adapter,
+        uint256 expectedTargetChainId
+    ) Reporter(headerStorage, yaho) {
+        VEA_INBOX = veaInbox_;
+        ADAPTER = adapter;
+        EXPECTED_TARGET_CHAIN_ID = expectedTargetChainId;
+    }
+
+    function receiverGateway() external view override returns (address) {
+        return ADAPTER;
+    }
+
+    function veaInbox() external view override returns (IVeaInbox) {
+        return VEA_INBOX;
+    }
+
+    function _dispatch(uint256 targetChainId, address adapter, uint256[] memory ids, bytes32[] memory hashes)
+        internal
+        override
+        returns (bytes32)
+    {
+        if (targetChainId != EXPECTED_TARGET_CHAIN_ID) {
+            revert InvalidTargetChainId(targetChainId, EXPECTED_TARGET_CHAIN_ID);
+        }
+        if (adapter != ADAPTER) revert InvalidAdapter(adapter, ADAPTER);
+        uint64 msgId = VEA_INBOX.sendMessage(ADAPTER, abi.encode(ids, hashes));
+        return bytes32(uint256(msgId));
+    }
+}

package/contracts/src/vea/interfaces/IReceiverGateway.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+interface IReceiverGateway {
+    function veaOutbox() external view returns (address);
+    function senderGateway() external view returns (address);
+    function receiveMessage(address msgSender, bytes calldata msgData) external;
+}

package/contracts/src/vea/interfaces/ISenderGateway.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+import {IVeaInbox} from "./IVeaInbox.sol";
+
+interface ISenderGateway {
+    function veaInbox() external view returns (IVeaInbox);
+    function receiverGateway() external view returns (address);
+}

package/contracts/src/vea/interfaces/IVeaInbox.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.20;
+
+interface IVeaInbox {
+    /// @dev Sends an arbitrary message to receiving chain.
+    /// Note: Calls authenticated by receiving gateway checking the sender argument.
+    /// @param _to The cross-domain contract address which receives the calldata.
+    /// @param _data The message calldata, abi.encode(...)
+    /// @return msgId The index of the message in the inbox, as a message Id, needed to relay the message.
+    function sendMessage(address _to, bytes memory _data) external returns (uint64 msgId);
+}

package/dist/contracts/broadcast/1514-42161.json

@@ -0,0 +1,8 @@
+{
+    "lightbulb": "0x2773DCFb27C0ED863648AB0cd45e77cC77f00E94",
+    "lzAdapter": "0x0313f25f51f8846fdDFaBCb7F0672e4D3E1C0E76",
+    "lzReporter": "0x41E3cde8F10A02B329f85133F7F1f573d876c6d8",
+    "switch": "0xeD1995Ae173cb68CFd419d91AAee1698e2F5B894",
+    "yaho": "0x0313f25f51f8846fdDFaBCb7F0672e4D3E1C0E76",
+    "yaru": "0x43017e1d9f66f7E7Be4055CFf6a490F57aF9b8De"
+}

package/dist/contracts/broadcast/42161-1514.json

@@ -0,0 +1,8 @@
+{
+    "lightbulb": "0x1F851DE0e959ad33193e5449EC4C23A66eAdbCC7",
+    "lzAdapter": "0xd35B519d08d96188BB89dF874ED48314De84325b",
+    "lzReporter": "0xCd685286838ECdB6a307B6Ee51AcBBe7172d9757",
+    "switch": "0x592dc5Aaf28f860af5E01088C6Aa55AFCB057e61",
+    "yaho": "0xD0375320591ff87797CEb03CBeE80C82fD61BC77",
+    "yaru": "0x5f629f27BA26E17e7E309D886A8490d9e0124bd1"
+}

package/dist/contracts/broadcast/421614-10200.json

@@ -0,0 +1,12 @@
+{
+    "ccipReporter": "0xACe8c605BBf459f6BDEd6FEc31e5B5E2CcC39F36",
+    "ccipAdapter": "0xC1d4c6842e7388b53d09Bcc10Bd4FfC122c0c6DA",
+    "lightbulb": "0x5e6fcfCaa61e4Db57858b7611eD2eC9Fb8e450dd",
+    "lzAdapter": "0x746dfa0251A31e587E97bBe0c58ED67A343280Df",
+    "lzReporter": "0x288dA9f5b01D9118AD0A1Fb998C1295fF1cf5c80",
+    "veaReporter": "0xbfDc8d1a106041b6c71044E0d7C94050B99eff84",
+    "veaAdapter": "0xd578fa969579CB7b560446D486C8451cd454C8cd",
+    "switch": "0x69E0ADAa6571422D174fc3e43e357c09465D0E75",
+    "yaho": "0xDbdF80c87f414fac8342e04D870764197bD3bAC7",
+    "yaru": "0x231e48AAEaAC6398978a1dBA4Cd38fcA208Ec391"
+}

package/dist/contracts/broadcast/421614-11155111.json

@@ -0,0 +1,12 @@
+{
+    "ccipReporter": "0x8777F17F5ACE97f6d1E6Df41c94F84075fAEBf1B",
+    "ccipAdapter": "0xc3613d84d156110Bc12aA4184C7EeFB1F8BD9cD2",
+    "lightbulb": "0x44d3d3d8cB731958Df78DAf531b16E23DfB27450",
+    "lzAdapter": "0x5d8FA84CB2c649b19A2F3C1EC2F3210c2AE4B2F3",
+    "lzReporter": "0x25af7138f50CEf2573bb67A0227aB44045B7CC88",
+    "veaReporter": "0xE803DA11AfC72CEa6Fa1A0AfC344015Cce5410A9",
+    "veaAdapter": "0x8C04D410B1F3B5907dDf4F017FAf7DF1D7f5F597",
+    "switch": "0x69E0ADAa6571422D174fc3e43e357c09465D0E75",
+    "yaho": "0xDbdF80c87f414fac8342e04D870764197bD3bAC7",
+    "yaru": "0x231e48AAEaAC6398978a1dBA4Cd38fcA208Ec391"
+}

package/dist/sdk/abi/Adapter.json

@@ -0,0 +1,71 @@
+[
+    {
+        "type": "function",
+        "name": "getHash",
+        "inputs": [
+            {
+                "name": "domain",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "",
+                "type": "bytes32",
+                "internalType": "bytes32"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "event",
+        "name": "HashStored",
+        "inputs": [
+            {
+                "name": "id",
+                "type": "uint256",
+                "indexed": true,
+                "internalType": "uint256"
+            },
+            {
+                "name": "hash",
+                "type": "bytes32",
+                "indexed": true,
+                "internalType": "bytes32"
+            }
+        ],
+        "anonymous": false
+    },
+    {
+        "type": "error",
+        "name": "ConflictingBlockHeader",
+        "inputs": [
+            {
+                "name": "blockNumber",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "blockHash",
+                "type": "bytes32",
+                "internalType": "bytes32"
+            },
+            {
+                "name": "storedBlockHash",
+                "type": "bytes32",
+                "internalType": "bytes32"
+            }
+        ]
+    },
+    {
+        "type": "error",
+        "name": "InvalidBlockHeaderRLP",
+        "inputs": []
+    }
+]

package/dist/sdk/abi/Hashi.json

@@ -0,0 +1,171 @@
+[
+    {
+        "type": "function",
+        "name": "checkHashWithThresholdFromAdapters",
+        "inputs": [
+            {
+                "name": "domain",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "threshold",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "adapters",
+                "type": "address[]",
+                "internalType": "contract IAdapter[]"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool",
+                "internalType": "bool"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "function",
+        "name": "getHash",
+        "inputs": [
+            {
+                "name": "domain",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "adapters",
+                "type": "address[]",
+                "internalType": "contract IAdapter[]"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "hash",
+                "type": "bytes32",
+                "internalType": "bytes32"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "function",
+        "name": "getHashFromAdapter",
+        "inputs": [
+            {
+                "name": "domain",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "adapter",
+                "type": "address",
+                "internalType": "contract IAdapter"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "",
+                "type": "bytes32",
+                "internalType": "bytes32"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "function",
+        "name": "getHashesFromAdapters",
+        "inputs": [
+            {
+                "name": "domain",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "id",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "adapters",
+                "type": "address[]",
+                "internalType": "contract IAdapter[]"
+            }
+        ],
+        "outputs": [
+            {
+                "name": "",
+                "type": "bytes32[]",
+                "internalType": "bytes32[]"
+            }
+        ],
+        "stateMutability": "view"
+    },
+    {
+        "type": "error",
+        "name": "AdaptersDisagree",
+        "inputs": [
+            {
+                "name": "adapterOne",
+                "type": "address",
+                "internalType": "contract IAdapter"
+            },
+            {
+                "name": "adapterTwo",
+                "type": "address",
+                "internalType": "contract IAdapter"
+            }
+        ]
+    },
+    {
+        "type": "error",
+        "name": "HashNotAvailableInAdapter",
+        "inputs": [
+            {
+                "name": "adapter",
+                "type": "address",
+                "internalType": "contract IAdapter"
+            }
+        ]
+    },
+    {
+        "type": "error",
+        "name": "InvalidThreshold",
+        "inputs": [
+            {
+                "name": "threshold",
+                "type": "uint256",
+                "internalType": "uint256"
+            },
+            {
+                "name": "maxThreshold",
+                "type": "uint256",
+                "internalType": "uint256"
+            }
+        ]
+    },
+    {
+        "type": "error",
+        "name": "NoAdaptersGiven",
+        "inputs": []
+    }
+]