Plume Repo Setup (#2485)

* Repo setup for Plume

* add provider URL config

* switch to the legacy testnet that has the rooster AMM deployed

* [Ethereum][Plume] Deploy LayerZero Adapter for wOETH (#2486)

* Layerzero bridge stuff

* Revert change and add tooling

* Update OmnichainL2Adapter

* Cleanup

* Fix WOETHPlume

* Wait for block confirmation

* Fix slither on Vault

* Plume Vault and Token deploy (#2489)

* Layerzero bridge stuff

* Revert change and add tooling

* Update OmnichainL2Adapter

* Cleanup

* Fix WOETHPlume

* Wait for block confirmation

* Fix slither on Vault

* cleanup code

* Tweaks

* Also, add a temp dripper

* Fix tests

* Deploy core contracts

* Exclude layerzero from slither

---------

Co-authored-by: Domen Grabec <[email protected]>

Author: shahthepro

.github/workflows/defi.yml

@@ -294,6 +294,46 @@ jobs:
             ./contracts/coverage.json
             ./contracts/coverage/**/*
           retention-days: 1
+  
+  contracts-plume-forktest:
+    name: "Plume Fork Tests"
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    env:
+      HARDHAT_CACHE_DIR: ./cache
+      PROVIDER_URL: ${{ secrets.PROVIDER_URL }}
+      PLUME_PROVIDER_URL: ${{ secrets.PLUME_PROVIDER_URL }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20.x"
+          cache: "yarn"
+          cache-dependency-path: contracts/yarn.lock
+
+      - uses: actions/cache@v4
+        id: hardhat-cache
+        with:
+          path: contracts/cache
+          key: ${{ runner.os }}-hardhat-${{ hashFiles('contracts/cache/*.json') }}
+          restore-keys: |
+            ${{ runner.os }}-hardhat-cache
+
+      - run: yarn install --frozen-lockfile
+        working-directory: ./contracts
+
+      - run: yarn run test:coverage:plume-fork
+        working-directory: ./contracts
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: fork-test-plume-coverage-${{ github.sha }}
+          path: | 
+            ./contracts/coverage.json
+            ./contracts/coverage/**/*
+          retention-days: 1
 
   coverage-uploader:
     name: "Upload Coverage Reports"
@@ -306,6 +346,7 @@ jobs:
       - contracts-arb-forktest
       - contracts-base-forktest
       - contracts-sonic-forktest
+      - contracts-plume-forktest
     env:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
     steps:

contracts/contracts/bridges/OmnichainL2Adapter.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import { MintBurnOFTAdapter } from "@layerzerolabs/oft-evm/contracts/MintBurnOFTAdapter.sol";
+import { IMintableBurnable } from "@layerzerolabs/oft-evm/contracts/interfaces/IMintableBurnable.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+/// NOTE: It's necessary to inherit from Ownable instead of Governable
+///       because OFTCore uses Ownable to manage the governor.
+///       Ownable uses slot 0 for storing the address, whereas Goveranble
+///       stores it in a computed slot.
+
+/// @notice Omnichain uses a deployed ERC-20 token and safeERC20
+///         to interact with the OFTCore contract.
+///         On L2, we follow the mint and burn mechanism.
+///         The adapter should have minter and burner roles.
+
+/// @title Omnichain L2 Adapter
+contract OmnichainL2Adapter is MintBurnOFTAdapter {
+    constructor(
+        address _token,
+        address _lzEndpoint,
+        address _governor
+    )
+        MintBurnOFTAdapter(
+            _token,
+            IMintableBurnable(_token),
+            _lzEndpoint,
+            _governor
+        )
+        Ownable()
+    {
+        _transferOwnership(_governor);
+    }
+
+    /// @inheritdoc MintBurnOFTAdapter
+    function _debit(
+        address _from,
+        uint256 _amountLD,
+        uint256 _minAmountLD,
+        uint32 _dstEid
+    )
+        internal
+        virtual
+        override
+        returns (uint256 amountSentLD, uint256 amountReceivedLD)
+    {
+        (amountSentLD, amountReceivedLD) = _debitView(
+            _amountLD,
+            _minAmountLD,
+            _dstEid
+        );
+        // Burns tokens from the caller.
+        IMintableERC20(address(minterBurner)).burn(_from, amountSentLD);
+    }
+
+    /// @inheritdoc MintBurnOFTAdapter
+    function _credit(
+        address _to,
+        uint256 _amountLD,
+        uint32 /* _srcEid */
+    ) internal virtual override returns (uint256 amountReceivedLD) {
+        if (_to == address(0x0)) _to = address(0xdead); // _mint(...) does not support address(0x0)
+        // Mints the tokens and transfers to the recipient.
+        IMintableERC20(address(minterBurner)).mint(_to, _amountLD);
+        // In the case of NON-default OFTAdapter, the amountLD MIGHT not be equal to amountReceivedLD.
+        return _amountLD;
+    }
+}
+
+interface IMintableERC20 {
+    function mint(address to, uint256 value) external;
+
+    function burn(address to, uint256 value) external;
+}

contracts/contracts/bridges/OmnichainMainnetAdapter.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import { OFTAdapter } from "@layerzerolabs/oft-evm/contracts/OFTAdapter.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+/// NOTE: It's necessary to inherit from Ownable instead of Governable
+///       because OFTCore uses Ownable to manage the governor.
+///       Ownable uses slot 0 for storing the address, whereas Goveranble
+///       stores it in a computed slot.
+
+/// @notice Omnichain uses a deployed ERC-20 token and safeERC20
+///         to interact with the OFTCore contract.
+///         On Ethereum, we follow the lock and unlock mechanism.
+
+/// @title Omnichain Mainnet Adapter
+contract OmnichainMainnetAdapter is OFTAdapter {
+    constructor(
+        address _token,
+        address _lzEndpoint,
+        address _governor
+    ) OFTAdapter(_token, _lzEndpoint, _governor) Ownable() {
+        _transferOwnership(_governor);
+    }
+}

contracts/contracts/interfaces/IVault.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.0;
 import { VaultStorage } from "../vault/VaultStorage.sol";
 
 interface IVault {
+    // slither-disable-start constable-states
+
     event AssetSupported(address _asset);
     event AssetDefaultStrategyUpdated(address _asset, address _strategy);
     event AssetAllocated(address _asset, address _strategy, uint256 _amount);

contracts/contracts/proxies/PlumeProxies.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { InitializeGovernedUpgradeabilityProxy } from "./InitializeGovernedUpgradeabilityProxy.sol";
+
+/**
+ * @notice OETHPlumeVaultProxy delegates calls to OETHPlumeVault implementation
+ */
+contract OETHPlumeVaultProxy is InitializeGovernedUpgradeabilityProxy {
+
+}
+
+/**
+ * @notice OETHPlumeProxy delegates calls to OETH implementation
+ */
+contract OETHPlumeProxy is InitializeGovernedUpgradeabilityProxy {
+
+}
+
+/**
+ * @notice WOETHPlumeProxy delegates calls to WOETH implementation
+ */
+contract WOETHPlumeProxy is InitializeGovernedUpgradeabilityProxy {
+
+}

contracts/contracts/token/OETHPlume.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { OUSD } from "./OUSD.sol";
+
+/**
+ * @title Super OETH (Plume) Token Contract
+ * @author Origin Protocol Inc
+ */
+contract OETHPlume is OUSD {
+    constructor() {
+        // Nobody owns the implementation contract
+        _setGovernor(address(0));
+    }
+
+    function symbol() external pure override returns (string memory) {
+        return "superOETHp";
+    }
+
+    function name() external pure override returns (string memory) {
+        return "Super OETH";
+    }
+
+    function decimals() external pure override returns (uint8) {
+        return 18;
+    }
+}

contracts/contracts/token/WOETHPlume.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { WOETH } from "./WOETH.sol";
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * @title wOETH (Plume) Token Contract
+ * @author Origin Protocol Inc
+ */
+
+contract WOETHPlume is WOETH {
+    constructor(ERC20 underlying_) WOETH(underlying_) {}
+
+    function name() public view virtual override returns (string memory) {
+        return "Wrapped Super OETH";
+    }
+
+    function symbol() public view virtual override returns (string memory) {
+        return "wsuperOETHp";
+    }
+}

contracts/deploy/mainnet/133_omnichain_adapter.js

@@ -0,0 +1,30 @@
+const {
+  deploymentWithGovernanceProposal,
+  deployWithConfirmation,
+} = require("../../utils/deploy");
+
+const addresses = require("../../utils/addresses");
+
+module.exports = deploymentWithGovernanceProposal(
+  {
+    deployName: "133_omnichain_adapter",
+  },
+  async ({ ethers }) => {
+    const { deployerAddr } = await getNamedAccounts();
+
+    const cWOETHProxy = await ethers.getContract("WOETHProxy");
+
+    // NOTE: For now, deployer is the governor to test things out
+    const dOmnichainMainnetAdapter = await deployWithConfirmation(
+      "OmnichainMainnetAdapter",
+      [cWOETHProxy.address, addresses.mainnet.LayerZeroEndpointV2, deployerAddr]
+    );
+
+    console.log(
+      "OmnichainMainnetAdapter address:",
+      dOmnichainMainnetAdapter.address
+    );
+
+    return {};
+  }
+);

contracts/deploy/plume/000_mock.js

@@ -0,0 +1,20 @@
+const { deployOnPlume } = require("../../utils/deploy-l2");
+const { deployWithConfirmation } = require("../../utils/deploy");
+const { replaceContractAt } = require("../../utils/hardhat");
+const addresses = require("../../utils/addresses");
+
+module.exports = deployOnPlume(
+  {
+    deployName: "000_mock",
+    forceSkip: true,
+  },
+  async () => {
+    // Just a workaround to get WETH on testnet
+    await deployWithConfirmation("MockWETH", []);
+    const mockWETH = await ethers.getContract("MockWETH");
+    await replaceContractAt(addresses.plume.WETH, mockWETH);
+
+    const weth = await ethers.getContractAt("MockWETH", addresses.plume.WETH);
+    console.log("MockWETH live at", weth.address);
+  }
+);

contracts/deploy/plume/001_woeth.js

@@ -0,0 +1,84 @@
+const { deployOnPlume } = require("../../utils/deploy-l2");
+const {
+  deployWithConfirmation,
+  withConfirmation,
+} = require("../../utils/deploy");
+const { getTxOpts } = require("../../utils/tx");
+const addresses = require("../../utils/addresses");
+
+module.exports = deployOnPlume(
+  {
+    deployName: "001_woeth",
+  },
+  async ({ ethers }) => {
+    const { deployerAddr } = await getNamedAccounts();
+    const sDeployer = await ethers.provider.getSigner(deployerAddr);
+
+    // Deploy Proxy
+    await deployWithConfirmation("BridgedWOETHProxy", []);
+    const cWOETHProxy = await ethers.getContract("BridgedWOETHProxy");
+    console.log("BridgedWOETHProxy address:", cWOETHProxy.address);
+
+    // Deploy Bridged WOETH Token implementation
+    await deployWithConfirmation("BridgedWOETH", []);
+    const cWOETHImpl = await ethers.getContract("BridgedWOETH");
+    console.log("BridgedWOETH address:", cWOETHImpl.address);
+
+    const cWOETH = await ethers.getContractAt(
+      "BridgedWOETH",
+      cWOETHProxy.address
+    );
+
+    const initData = cWOETHImpl.interface.encodeFunctionData(
+      "initialize()",
+      []
+    );
+
+    // Initialize the proxy
+    // prettier-ignore
+    await withConfirmation(
+      cWOETHProxy
+        .connect(sDeployer)["initialize(address,address,bytes)"](
+          cWOETHImpl.address,
+          deployerAddr, // Pretend Deployer is Governor for now
+          initData,
+          await getTxOpts()
+        )
+    );
+    console.log("Initialized BridgedWOETHProxy");
+
+    // Deploy OmnichainL2Adapter
+    const dOmnichainL2Adapter = await deployWithConfirmation(
+      "OmnichainL2Adapter",
+      [cWOETHProxy.address, addresses.plume.LayerZeroEndpointV2, deployerAddr]
+    );
+
+    console.log("OmnichainL2Adapter address:", dOmnichainL2Adapter.address);
+
+    // Grant permissions to the adapter
+    await withConfirmation(
+      cWOETH
+        .connect(sDeployer)
+        .grantRole(await cWOETHImpl.MINTER_ROLE(), dOmnichainL2Adapter.address)
+    );
+
+    await withConfirmation(
+      cWOETH
+        .connect(sDeployer)
+        .grantRole(await cWOETHImpl.BURNER_ROLE(), dOmnichainL2Adapter.address)
+    );
+    console.log("Granted minter & burner roles to OmnichainL2Adapter");
+
+    // Set Peer
+    const cOmnichainL2Adapter = await ethers.getContract("OmnichainL2Adapter");
+
+    await withConfirmation(
+      cOmnichainL2Adapter.connect(sDeployer).setPeer(
+        // Ref: https://docs.layerzero.network/v2/deployments/deployed-contracts
+        "30101", // Ethereum endpoint ID
+        ethers.utils.zeroPad(addresses.mainnet.WOETHOmnichainAdapter, 32)
+      )
+    );
+    console.log("Peer set for OmnichainL2Adapter");
+  }
+);