@piplabs/story-contracts 0.1.0-alpha.0

package/test/timelock/Timelock.t.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+
+import { Test } from "../utils/Test.sol";
+import { IPTokenStaking } from "../../src/protocol/IPTokenStaking.sol";
+import { TimelockController } from "@openzeppelin/contracts/governance/TimelockController.sol";
+
+contract TimelockTest is Test {
+    function setUp() public override {
+        super.setUp();
+    }
+
+    function testCancelBeforeExecute() public {
+        // Prepare a sample operation
+        address target = address(ipTokenStaking);
+        uint256 value = 0;
+        bytes memory data = abi.encodeWithSelector(IPTokenStaking.setFee.selector, 2 ether);
+        bytes32 predecessor = bytes32(0);
+        bytes32 salt = keccak256("TEST_SALT");
+        uint256 delay = timelock.getMinDelay();
+
+        // Schedule the operation
+        vm.prank(admin);
+        timelock.schedule(target, value, data, predecessor, salt, delay);
+
+        // Ensure the operation is pending
+        bytes32 operationId = timelock.hashOperation(target, value, data, predecessor, salt);
+        assertTrue(timelock.isOperationPending(operationId));
+
+        // Cancel the operation
+        vm.prank(admin);
+        timelock.cancel(operationId);
+
+        // Ensure the operation is no longer pending
+        assertFalse(timelock.isOperationPending(operationId));
+
+        // Wait for the delay to pass
+        vm.warp(block.timestamp + delay + 1);
+
+        // Try to execute the cancelled operation
+        vm.prank(executor);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                TimelockController.TimelockUnexpectedOperationState.selector,
+                operationId,
+                bytes32(1 << uint8(TimelockController.OperationState.Ready))
+            )
+        );
+
+        timelock.execute(target, value, data, predecessor, salt);
+
+        // Verify that the fee wasn't changed
+        assertEq(ipTokenStaking.fee(), 1 ether);
+    }
+
+    function testExecuteSequenceWithPredecessors() public {
+        // Prepare sample operations
+        address target = address(ipTokenStaking);
+        uint256 value = 0;
+        bytes memory data1 = abi.encodeWithSelector(IPTokenStaking.setFee.selector, 2 ether);
+        bytes memory data2 = abi.encodeWithSelector(IPTokenStaking.setFee.selector, 3 ether);
+        bytes memory data3 = abi.encodeWithSelector(IPTokenStaking.setFee.selector, 4 ether);
+        bytes32 salt1 = keccak256("SALT_1");
+        bytes32 salt2 = keccak256("SALT_2");
+        bytes32 salt3 = keccak256("SALT_3");
+        uint256 delay = timelock.getMinDelay();
+
+        // Schedule the first operation
+        vm.prank(admin);
+        timelock.schedule(target, value, data1, bytes32(0), salt1, delay);
+        bytes32 id1 = timelock.hashOperation(target, value, data1, bytes32(0), salt1);
+
+        // Schedule the second operation with the first as predecessor
+        vm.prank(admin);
+        timelock.schedule(target, value, data2, id1, salt2, delay);
+        bytes32 id2 = timelock.hashOperation(target, value, data2, id1, salt2);
+
+        // Schedule the third operation with the second as predecessor
+        vm.prank(admin);
+        timelock.schedule(target, value, data3, id2, salt3, delay);
+
+        // Wait for the delay to pass
+        vm.warp(block.timestamp + delay + 1);
+
+        // Execute the first operation
+        vm.prank(executor);
+        timelock.execute(target, value, data1, bytes32(0), salt1);
+        assertEq(ipTokenStaking.fee(), 2 ether);
+
+        // Try to execute the third operation (should fail due to unexecuted predecessor)
+        vm.prank(executor);
+        vm.expectRevert(abi.encodeWithSelector(TimelockController.TimelockUnexecutedPredecessor.selector, id2));
+        timelock.execute(target, value, data3, id2, salt3);
+
+        // Execute the second operation
+        vm.prank(executor);
+        timelock.execute(target, value, data2, id1, salt2);
+        assertEq(ipTokenStaking.fee(), 3 ether);
+
+        // Finally, execute the third operation
+        vm.prank(executor);
+        timelock.execute(target, value, data3, id2, salt3);
+        assertEq(ipTokenStaking.fee(), 4 ether);
+    }
+
+    function testTimelockMinDelay() public {
+        address target = address(ipTokenStaking);
+        uint256 value = 0;
+        bytes memory data1 = abi.encodeWithSelector(IPTokenStaking.setFee.selector, 2 ether);
+        bytes32 salt1 = keccak256("SALT_1");
+        uint256 minDelay = timelock.getMinDelay();
+
+        // Scheduling under the min delay should fail
+        vm.expectRevert(
+            abi.encodeWithSelector(TimelockController.TimelockInsufficientDelay.selector, minDelay - 1, minDelay)
+        );
+        vm.prank(admin);
+        timelock.schedule(target, value, data1, bytes32(0), salt1, minDelay - 1);
+
+        // Scheduling over the min delay should succeed
+        vm.prank(admin);
+        timelock.schedule(target, value, data1, bytes32(0), salt1, minDelay + 1 minutes);
+
+        // Should revert if we try to execute before scheduled time
+        vm.warp(block.timestamp + minDelay);
+        vm.expectRevert();
+        vm.prank(executor);
+        timelock.execute(target, value, data1, bytes32(0), salt1);
+
+        // Should succeed if we wait for the delay to pass
+        vm.warp(block.timestamp + minDelay + 1 minutes);
+        vm.prank(executor);
+        timelock.execute(target, value, data1, bytes32(0), salt1);
+        assertEq(ipTokenStaking.fee(), 2 ether);
+    }
+}

package/test/token/WIP.t.sol

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import { Test } from "../utils/Test.sol";
+import { WIP } from "../../src/token/WIP.sol";
+
+contract ContractWithoutReceive {}
+
+contract WIPTest is Test {
+    function testMetadata() public view {
+        assertEq(wip.name(), "Wrapped IP");
+        assertEq(wip.symbol(), "WIP");
+        assertEq(wip.decimals(), 18);
+    }
+
+    function testFallbackDeposit() public {
+        assertEq(wip.balanceOf(address(this)), 0);
+        assertEq(wip.totalSupply(), 0);
+
+        (bool success, ) = address(wip).call{ value: 1 ether }("");
+        assertTrue(success);
+
+        assertEq(wip.balanceOf(address(this)), 1 ether);
+        assertEq(wip.totalSupply(), 1 ether);
+    }
+
+    function testDeposit() public {
+        assertEq(wip.balanceOf(address(this)), 0);
+        assertEq(wip.totalSupply(), 0);
+
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(address(this)), 1 ether);
+        assertEq(wip.totalSupply(), 1 ether);
+    }
+
+    function testWithdraw() public {
+        uint256 startingBalance = address(this).balance;
+
+        wip.deposit{ value: 1 ether }();
+
+        wip.withdraw(1 ether);
+
+        uint256 balanceAfterWithdraw = address(this).balance;
+
+        assertEq(balanceAfterWithdraw, startingBalance);
+        assertEq(wip.balanceOf(address(this)), 0);
+        assertEq(wip.totalSupply(), 0);
+    }
+
+    function testPartialWithdraw() public {
+        wip.deposit{ value: 1 ether }();
+
+        uint256 balanceBeforeWithdraw = address(this).balance;
+
+        wip.withdraw(0.5 ether);
+
+        uint256 balanceAfterWithdraw = address(this).balance;
+
+        assertEq(balanceAfterWithdraw, balanceBeforeWithdraw + 0.5 ether);
+        assertEq(wip.balanceOf(address(this)), 0.5 ether);
+        assertEq(wip.totalSupply(), 0.5 ether);
+    }
+
+    function testWithdrawToContractWithoutReceiveReverts() public {
+        address owner = address(new ContractWithoutReceive());
+
+        vm.deal(owner, 1 ether);
+
+        vm.prank(owner);
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(owner), 1 ether);
+
+        vm.expectRevert(WIP.IPTransferFailed.selector);
+        vm.prank(owner);
+        wip.withdraw(1 ether);
+    }
+
+    function testFallbackDeposit(uint256 amount) public {
+        amount = _bound(amount, 0, address(this).balance);
+
+        assertEq(wip.balanceOf(address(this)), 0);
+        assertEq(wip.totalSupply(), 0);
+
+        (bool success, ) = address(wip).call{ value: amount }("");
+        assertTrue(success);
+
+        assertEq(wip.balanceOf(address(this)), amount);
+        assertEq(wip.totalSupply(), amount);
+    }
+
+    function testDeposit(uint256 amount) public {
+        amount = _bound(amount, 0, address(this).balance);
+
+        assertEq(wip.balanceOf(address(this)), 0);
+        assertEq(wip.totalSupply(), 0);
+
+        wip.deposit{ value: amount }();
+
+        assertEq(wip.balanceOf(address(this)), amount);
+        assertEq(wip.totalSupply(), amount);
+    }
+
+    function testWithdraw(uint256 depositAmount, uint256 withdrawAmount) public {
+        depositAmount = _bound(depositAmount, 0, address(this).balance);
+        withdrawAmount = _bound(withdrawAmount, 0, depositAmount);
+
+        wip.deposit{ value: depositAmount }();
+
+        uint256 balanceBeforeWithdraw = address(this).balance;
+
+        wip.withdraw(withdrawAmount);
+
+        uint256 balanceAfterWithdraw = address(this).balance;
+
+        assertEq(balanceAfterWithdraw, balanceBeforeWithdraw + withdrawAmount);
+        assertEq(wip.balanceOf(address(this)), depositAmount - withdrawAmount);
+        assertEq(wip.totalSupply(), depositAmount - withdrawAmount);
+    }
+
+    function testTransferToZeroAddressReverts() public {
+        address owner = address(0x123);
+
+        vm.deal(owner, 1 ether);
+
+        vm.prank(owner);
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(owner), 1 ether);
+
+        vm.expectRevert(abi.encodeWithSelector(WIP.ERC20InvalidReceiver.selector, address(0)));
+        vm.prank(owner);
+        wip.transfer(address(0), 1 ether);
+    }
+
+    function testTransferToWIPContractReverts() public {
+        address owner = address(0x123);
+
+        vm.deal(owner, 1 ether);
+
+        vm.prank(owner);
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(owner), 1 ether);
+
+        vm.expectRevert(abi.encodeWithSelector(WIP.ERC20InvalidReceiver.selector, address(wip)));
+        vm.prank(owner);
+        wip.transfer(address(wip), 1 ether);
+    }
+
+    function testTransferFromReceiverIsWIPContractReverts() public {
+        address owner = address(0x123);
+
+        vm.deal(owner, 1 ether);
+
+        vm.prank(owner);
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(owner), 1 ether);
+
+        vm.expectRevert(abi.encodeWithSelector(WIP.ERC20InvalidReceiver.selector, address(wip)));
+        vm.prank(owner);
+        wip.transferFrom(owner, address(wip), 1 ether);
+    }
+
+    function testTransferFromReceiverIsZeroAddressReverts() public {
+        address owner = address(0x123);
+
+        vm.deal(owner, 1 ether);
+
+        vm.prank(owner);
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(owner), 1 ether);
+
+        vm.expectRevert(abi.encodeWithSelector(WIP.ERC20InvalidReceiver.selector, address(0)));
+        vm.prank(owner);
+        wip.transferFrom(owner, address(0), 1 ether);
+    }
+
+    function testApprovalToSelfReverts() public {
+        address owner = address(0x123);
+
+        vm.deal(owner, 1 ether);
+
+        vm.prank(owner);
+        wip.deposit{ value: 1 ether }();
+
+        assertEq(wip.balanceOf(owner), 1 ether);
+
+        vm.expectRevert(abi.encodeWithSelector(WIP.ERC20InvalidSpender.selector, owner));
+        vm.prank(owner);
+        wip.approve(owner, 1 ether);
+    }
+
+    receive() external payable {}
+}

package/test/ubipool/UBIPool.t.sol

@@ -0,0 +1,239 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+/* solhint-disable no-console */
+/* solhint-disable max-line-length */
+/// NOTE: pragma allowlist-secret must be inline (same line as the pubkey hex string) to avoid false positive
+/// flag "Hex High Entropy String" in CI run detect-secrets
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+import { IUBIPool } from "../../src/interfaces/IUBIPool.sol";
+import { Test } from "../utils/Test.sol";
+import { ValidatorData } from "../data/ValidatorData.sol";
+
+contract UBIPoolTest is Test, ValidatorData {
+    function setUp() public virtual override {
+        super.setUp();
+    }
+
+    function test_setUBIPercentage() public {
+        // Fail if not protocol admin
+        vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, address(this)));
+        ubiPool.setUBIPercentage(12_00);
+
+        // Fail if percentage too high
+        uint32 tooMuch = ubiPool.MAX_UBI_PERCENTAGE() + 1;
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIPercentage.selector, tooMuch),
+            "UBIPool: percentage too high"
+        );
+
+        // Set percentage
+        schedule(address(ubiPool), abi.encodeWithSelector(IUBIPool.setUBIPercentage.selector, 12_00));
+        waitForTimelock();
+        vm.expectEmit(true, true, true, true);
+        emit IUBIPool.UBIPercentageSet(12_00);
+        executeTimelocked(address(ubiPool), abi.encodeWithSelector(IUBIPool.setUBIPercentage.selector, 12_00));
+    }
+
+    function test_setUBIDistribution_claimUBI() public {
+        uint256[] memory amounts = new uint256[](validators.length);
+        bytes[] memory validatorCmpPubKeys = new bytes[](validators.length);
+        uint256 totalAmount = 0;
+        for (uint256 i = 0; i < validators.length; i++) {
+            amounts[i] = 100 ether + i * 10 ether;
+            validatorCmpPubKeys[i] = validators[i].compressedHex;
+            totalAmount += amounts[i];
+            vm.prank(validators[i].evmAddress);
+            vm.expectRevert("UBIPool: no UBI to claim");
+            ubiPool.claimUBI(1, validatorCmpPubKeys[i]);
+        }
+        vm.deal(address(ubiPool), totalAmount);
+        performTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, totalAmount, validatorCmpPubKeys, amounts)
+        );
+        assertEq(ubiPool.currentDistributionId(), 1);
+
+        for (uint256 i = 0; i < validators.length; i++) {
+            uint256 amount = amounts[i];
+            assertEq(ubiPool.validatorUBIAmounts(1, validatorCmpPubKeys[i]), amount);
+            vm.prank(validators[i].evmAddress);
+            uint256 balanceBefore = address(validators[i].evmAddress).balance;
+            uint256 poolBalanceBefore = address(ubiPool).balance;
+            ubiPool.claimUBI(1, validatorCmpPubKeys[i]);
+            assertEq(address(validators[i].evmAddress).balance, balanceBefore + amount);
+            assertEq(address(ubiPool).balance, poolBalanceBefore - amount);
+            assertEq(ubiPool.validatorUBIAmounts(1, validatorCmpPubKeys[i]), 0);
+        }
+        vm.deal(address(ubiPool), totalAmount);
+        performTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, totalAmount, validatorCmpPubKeys, amounts),
+            bytes32(keccak256("setUBIDistribution 2nd time"))
+        );
+        assertEq(ubiPool.currentDistributionId(), 2);
+
+        for (uint256 i = 0; i < validators.length; i++) {
+            uint256 amount = amounts[i];
+            assertEq(ubiPool.validatorUBIAmounts(2, validatorCmpPubKeys[i]), amount);
+            vm.prank(validators[i].evmAddress);
+            uint256 balanceBefore = address(validators[i].evmAddress).balance;
+            uint256 poolBalanceBefore = address(ubiPool).balance;
+            ubiPool.claimUBI(2, validatorCmpPubKeys[i]);
+            assertEq(address(validators[i].evmAddress).balance, balanceBefore + amount);
+            assertEq(address(ubiPool).balance, poolBalanceBefore - amount);
+            assertEq(ubiPool.validatorUBIAmounts(2, validatorCmpPubKeys[i]), 0);
+        }
+    }
+
+    function test_setUBIDistribution_reverts() public {
+        // Fail if not protocol admin
+        vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, address(this)));
+        ubiPool.setUBIDistribution(100 ether, new bytes[](0), new uint256[](0));
+
+        // Fail if validatorCmpPubKeys is empty
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, 100 ether, new bytes[](0), new uint256[](0)),
+            "UBIPool: validatorCmpPubKeys cannot be empty"
+        );
+
+        // Fail if validatorCmpPubKeys and percentages do not match
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, 100 ether, new bytes[](1), new uint256[](0)),
+            "UBIPool: length mismatch"
+        );
+
+        // Fail if UBIPool: not enough balance
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, 100 ether, new bytes[](1), new uint256[](1)),
+            "UBIPool: not enough balance"
+        );
+
+        // Fail if amounts do not sum to totalUBI
+
+        uint256[] memory amounts = new uint256[](1);
+        bytes[] memory validatorCmpPubKeys = new bytes[](1);
+        validatorCmpPubKeys[0] = validators[0].compressedHex;
+        amounts[0] = 1 ether;
+        vm.deal(address(ubiPool), 100 ether);
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, 100 ether, validatorCmpPubKeys, amounts),
+            "UBIPool: total amount mismatch"
+        );
+
+        // Fail if one amount is zero
+        vm.deal(address(ubiPool), 100 ether);
+        amounts = new uint256[](1);
+        amounts[0] = 0;
+        validatorCmpPubKeys = new bytes[](1);
+        validatorCmpPubKeys[0] = validators[0].compressedHex;
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, 100 ether, validatorCmpPubKeys, amounts),
+            "UBIPool: amounts cannot be zero"
+        );
+
+        // Fail if pubkey is not valid
+        vm.deal(address(ubiPool), 100 ether);
+        amounts = new uint256[](1);
+        amounts[0] = 100 ether;
+        validatorCmpPubKeys = new bytes[](1);
+        // Invalid pubkey
+        validatorCmpPubKeys[
+            0
+        ] = hex"0482782124bc9cd03c38aa4cac234dc4e4e3cecf04d57914371baf7fa78ffb975f6d58e245bea952dd039f0fec4e9db418c3b00000"; // pragma: allowlist secret
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, 100 ether, validatorCmpPubKeys, amounts),
+            "Secp256k1Verifier: Invalid cmp pubkey length"
+        );
+    }
+
+    function test_claimUBI_revert_respect_unclaimed_tokens() public {
+        // Reverts if balance < totalPendingClaims + totalUBI
+        // Set initial distribution and claim some
+        uint256 totalAmount = 100 ether;
+        uint256[] memory amounts = new uint256[](2);
+        amounts[0] = 60 ether;
+        amounts[1] = 40 ether;
+        bytes[] memory validatorCmpPubKeys = new bytes[](2);
+        validatorCmpPubKeys[0] = validators[0].compressedHex;
+        validatorCmpPubKeys[1] = validators[1].compressedHex;
+
+        vm.deal(address(ubiPool), totalAmount);
+        performTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, totalAmount, validatorCmpPubKeys, amounts),
+            bytes32(keccak256("setUBIDistribution"))
+        );
+
+        // First validator claims their UBI
+        vm.prank(validators[0].evmAddress);
+        ubiPool.claimUBI(1, validatorCmpPubKeys[0]);
+
+        // Try to set new distribution with not enough balance
+        // Only 40 ether left in contract but 60 ether still pending claims
+        uint256 newTotalAmount = 1 ether;
+        uint256[] memory newAmounts = new uint256[](1);
+        newAmounts[0] = 1 ether;
+        bytes[] memory newValidatorUncmpPubKeys = new bytes[](1);
+        newValidatorUncmpPubKeys[0] = validators[0].compressedHex;
+
+        expectRevertTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(
+                IUBIPool.setUBIDistribution.selector,
+                newTotalAmount,
+                newValidatorUncmpPubKeys,
+                newAmounts
+            ),
+            "UBIPool: not enough balance"
+        );
+    }
+
+    function test_claimUBI_respect_unclaimed_tokens() public {
+        // Set initial distribution
+        uint256 totalAmount = 100 ether;
+        uint256[] memory amounts = new uint256[](2);
+        amounts[0] = 60 ether;
+        amounts[1] = 40 ether;
+        bytes[] memory validatorCmpPubKeys = new bytes[](2);
+        validatorCmpPubKeys[0] = validators[0].compressedHex;
+        validatorCmpPubKeys[1] = validators[1].compressedHex;
+
+        vm.deal(address(ubiPool), totalAmount + 10 ether); // Extra balance for next distribution
+        performTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(IUBIPool.setUBIDistribution.selector, totalAmount, validatorCmpPubKeys, amounts),
+            bytes32(keccak256("setUBIDistribution"))
+        );
+
+        // First validator claims their UBI
+        vm.prank(validators[0].evmAddress);
+        ubiPool.claimUBI(1, validatorCmpPubKeys[0]);
+
+        // Set new distribution with enough balance
+        // 40 ether pending claims + 10 ether extra balance = enough for 5 ether new distribution
+        uint256 newTotalAmount = 5 ether;
+        uint256[] memory newAmounts = new uint256[](1);
+        newAmounts[0] = 5 ether;
+        bytes[] memory newValidatorUncmpPubKeys = new bytes[](1);
+        newValidatorUncmpPubKeys[0] = validators[0].compressedHex;
+
+        performTimelocked(
+            address(ubiPool),
+            abi.encodeWithSelector(
+                IUBIPool.setUBIDistribution.selector,
+                newTotalAmount,
+                newValidatorUncmpPubKeys,
+                newAmounts
+            ),
+            bytes32(keccak256("setUBIDistribution"))
+        );
+    }
+}

package/test/upgrade-entrypoint/UpgradeEntryPoint.t.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+/* solhint-disable no-console */
+/* solhint-disable max-line-length */
+/// NOTE: pragma allowlist-secret must be inline (same line as the pubkey hex string) to avoid false positive
+/// flag "Hex High Entropy String" in CI run detect-secrets
+
+import { IUpgradeEntrypoint } from "../../src/protocol/UpgradeEntrypoint.sol";
+
+import { Test } from "../utils/Test.sol";
+
+contract UpgradeEntrypointTest is Test {
+    function testUpgradeEntrypoint_planUpgrade() public {
+        // Network shall allow the protocol owner to submit an upgrade plan.
+        string memory name = "upgrade";
+        int64 height = 1;
+        string memory info = "info";
+
+        schedule(
+            address(upgradeEntrypoint),
+            abi.encodeWithSelector(IUpgradeEntrypoint.planUpgrade.selector, name, height, info)
+        );
+        waitForTimelock();
+        vm.expectEmit(address(upgradeEntrypoint));
+        emit IUpgradeEntrypoint.SoftwareUpgrade(name, height, info);
+        executeTimelocked(
+            address(upgradeEntrypoint),
+            abi.encodeWithSelector(IUpgradeEntrypoint.planUpgrade.selector, name, height, info)
+        );
+
+        // Network shall not allow non-protocol owner to submit an upgrade plan.
+        address otherAddr = address(0xf398C12A45Bc409b6C652E25bb0a3e702492A4ab);
+        vm.prank(otherAddr);
+        vm.expectRevert();
+        upgradeEntrypoint.planUpgrade(name, height, info);
+    }
+}