feat: expand non-evm relay and route planning support

2026-04-18 12:05:34 -07:00
parent da78073104
commit 843cdbf71c
113 changed files with 8542 additions and 222 deletions
--- a/test/wrapped-lp-public/WrappedLPProgram.t.sol
+++ b/test/wrapped-lp-public/WrappedLPProgram.t.sol
@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+import {Chain138LPLocker} from "../../contracts/wrapped-lp-public/Chain138LPLocker.sol";
+import {WLPReceiptToken} from "../../contracts/wrapped-lp-public/WLPReceiptToken.sol";
+import {PublicChainMintController} from "../../contracts/wrapped-lp-public/PublicChainMintController.sol";
+import {WLPRedemptionGateway} from "../../contracts/wrapped-lp-public/WLPRedemptionGateway.sol";
+import {WrappedLPNAVVault} from "../../contracts/wrapped-lp-public/WrappedLPNAVVault.sol";
+import {WLPNAVOracle} from "../../contracts/wrapped-lp-public/WLPNAVOracle.sol";
+
+contract MockERC20 is ERC20 {
+    constructor(string memory n, string memory s) ERC20(n, s) {}
+
+    function mint(address to, uint256 a) external {
+        _mint(to, a);
+    }
+}
+
+contract WrappedLPProgramTest is Test {
+    MockERC20 lp;
+    Chain138LPLocker locker;
+    WLPReceiptToken wlp;
+    PublicChainMintController mintCtl;
+    WLPRedemptionGateway gateway;
+
+    address admin = address(this);
+    address relayer = address(0xBEEF);
+    address user = address(0xA11CE);
+
+    function setUp() public {
+        lp = new MockERC20("DODO LP", "DLP");
+        locker = new Chain138LPLocker(address(lp), admin);
+        wlp = new WLPReceiptToken("Wrapped LP", "wLP", 18, admin);
+        mintCtl = new PublicChainMintController(address(wlp), address(locker), admin);
+        gateway = new WLPRedemptionGateway(address(wlp), admin);
+
+        wlp.grantRole(wlp.MINTER_ROLE(), address(mintCtl));
+        wlp.grantRole(wlp.BURNER_ROLE(), address(gateway));
+        mintCtl.grantRole(mintCtl.RELAYER_ROLE(), relayer);
+        locker.grantRole(locker.BRIDGE_RELEASE_ROLE(), relayer);
+    }
+
+    function test_lock_mint_release_invariant() public {
+        uint256 amt = 1000e18;
+        lp.mint(user, amt);
+        vm.startPrank(user);
+        lp.approve(address(locker), amt);
+        bytes32 lockRef = locker.deposit(amt);
+        vm.stopPrank();
+
+        assertEq(locker.totalEscrowed(), amt);
+
+        vm.prank(relayer);
+        mintCtl.mintForLock(lockRef, user, amt);
+        assertEq(wlp.balanceOf(user), amt);
+
+        vm.expectRevert();
+        vm.prank(relayer);
+        mintCtl.mintForLock(lockRef, user, amt);
+
+        vm.prank(user);
+        gateway.requestRedeem(amt);
+        assertEq(wlp.balanceOf(user), 0);
+
+        vm.prank(relayer);
+        locker.releaseAmount(user, amt);
+        assertEq(locker.totalEscrowed(), 0);
+        assertEq(lp.balanceOf(user), amt);
+    }
+
+    function test_nav_vault_cap() public {
+        MockERC20 usdc = new MockERC20("USDC", "USDC");
+        WrappedLPNAVVault vault = new WrappedLPNAVVault(
+            usdc,
+            "Wrapped LP NAV Vault",
+            "wLPV",
+            admin
+        );
+        vault.setDepositCap(1_000_000e18);
+        usdc.mint(user, 2_000_000e18);
+        vm.startPrank(user);
+        usdc.approve(address(vault), type(uint256).max);
+        vm.expectRevert();
+        vault.deposit(1_500_000e18, user);
+        vm.stopPrank();
+    }
+
+    function test_nav_oracle_stale() public {
+        WLPNAVOracle oracle = new WLPNAVOracle(admin, 3600);
+        oracle.grantRole(oracle.KEEPER_ROLE(), relayer);
+        vm.prank(relayer);
+        oracle.submitAnswer(1e8);
+        assertFalse(oracle.isStale());
+        vm.warp(block.timestamp + 4000);
+        assertTrue(oracle.isStale());
+    }
+
+    /// @notice Fuzz: distinct deposits yield distinct lockRefs and independent mints.
+    function testFuzz_lockRef_unique(uint128 amtA, uint128 amtB) public {
+        vm.assume(amtA > 0 && amtB > 0);
+        vm.assume(amtA != amtB);
+
+        uint256 a = uint256(amtA) * 1e10;
+        uint256 b = uint256(amtB) * 1e10;
+
+        lp.mint(user, a + b);
+        vm.startPrank(user);
+        lp.approve(address(locker), a + b);
+        bytes32 rA = locker.deposit(a);
+        bytes32 rB = locker.deposit(b);
+        vm.stopPrank();
+
+        assertTrue(rA != rB);
+
+        vm.startPrank(relayer);
+        mintCtl.mintForLock(rA, user, a);
+        mintCtl.mintForLock(rB, user, b);
+        vm.stopPrank();
+
+        assertEq(wlp.balanceOf(user), a + b);
+    }
+}