@piplabs/story-contracts 0.1.0-alpha.0

package/src/protocol/UBIPool.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
+import { MulticallUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol";
+import { Secp256k1Verifier } from "./Secp256k1Verifier.sol";
+import { IUBIPool } from "../interfaces/IUBIPool.sol";
+
+/// @title UBIPool
+/// @notice Contract for distributing UBI to validators
+/// UBI comes from a percentage of the protocol's emmission during a defined period
+/// This % is minted to the UBIPool contract and can be claimed by validators
+/// Each validator can claim their UBI for a given month
+/// Distributions will be made public monthly by Story for community scrutiny,
+/// and if correct, will be distributed to validators via this contract
+contract UBIPool is
+    IUBIPool,
+    Ownable2StepUpgradeable,
+    ReentrancyGuardUpgradeable,
+    Secp256k1Verifier,
+    MulticallUpgradeable
+{
+    /// @notice The maximum UBI percentage
+    uint32 public immutable MAX_UBI_PERCENTAGE;
+
+    /// @notice The current distribution id, incremented for each new distribution
+    uint256 public currentDistributionId;
+
+    /// @notice The amount of UBI for each validator for a given distribution
+    mapping(uint256 distributionId => mapping(bytes validatorCmpPubkey => uint256 amount)) public validatorUBIAmounts;
+
+    /// @notice The total amount of pending tokens to claim.
+    /// Added when a distribution is set, and subtracted when a validator claims their UBI.
+    uint256 public totalPendingClaims;
+
+    constructor(uint32 maxUBIPercentage) {
+        MAX_UBI_PERCENTAGE = maxUBIPercentage;
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the contract.
+    /// @param owner The owner of the contract
+    function initialize(address owner) public initializer {
+        require(owner != address(0), "UBIPool: owner cannot be zero address");
+        __Ownable_init(owner);
+    }
+
+    /// @notice Sets the UBI percentage distribution in CL
+    /// @param percentage The percentage of the UBI
+    function setUBIPercentage(uint32 percentage) external onlyOwner {
+        require(percentage <= MAX_UBI_PERCENTAGE, "UBIPool: percentage too high");
+        emit UBIPercentageSet(percentage);
+    }
+
+    /// @notice Sets the UBI distribution for a given month
+    /// @param totalUBI The total amount of UBI
+    /// @param validatorCmpPubKeys The validator compressed public keys
+    /// @param amounts The amounts of UBI for each validator
+    /// @return distributionId The distribution id
+    function setUBIDistribution(
+        uint256 totalUBI,
+        bytes[] calldata validatorCmpPubKeys,
+        uint256[] calldata amounts
+    ) external onlyOwner returns (uint256) {
+        require(validatorCmpPubKeys.length > 0, "UBIPool: validatorCmpPubKeys cannot be empty");
+        require(validatorCmpPubKeys.length == amounts.length, "UBIPool: length mismatch");
+        require(totalUBI + totalPendingClaims <= address(this).balance, "UBIPool: not enough balance");
+        totalPendingClaims += totalUBI;
+        uint256 accAmount;
+        currentDistributionId++;
+        for (uint256 i = 0; i < amounts.length; i++) {
+            require(amounts[i] > 0, "UBIPool: amounts cannot be zero");
+            _verifyCmpPubkey(validatorCmpPubKeys[i]);
+            validatorUBIAmounts[currentDistributionId][validatorCmpPubKeys[i]] = amounts[i];
+            accAmount += amounts[i];
+        }
+        require(accAmount == totalUBI, "UBIPool: total amount mismatch");
+        emit UBIDistributionSet(currentDistributionId, totalUBI, validatorCmpPubKeys, amounts);
+        return currentDistributionId;
+    }
+
+    /// @notice Claims the UBI for a given month for a validator
+    /// @dev The validator address must be the one who is set to receive the UBI
+    /// @param distributionId The distribution id
+    /// @param validatorCmpPubkey The validator compressed public key
+    function claimUBI(
+        uint256 distributionId,
+        bytes calldata validatorCmpPubkey
+    ) external nonReentrant verifyCmpPubkeyWithExpectedAddress(validatorCmpPubkey, msg.sender) {
+        uint256 amount = validatorUBIAmounts[distributionId][validatorCmpPubkey];
+        require(amount > 0, "UBIPool: no UBI to claim");
+        validatorUBIAmounts[distributionId][validatorCmpPubkey] = 0;
+        (bool success, ) = msg.sender.call{ value: amount }("");
+        require(success, "UBIPool: failed to send UBI");
+        totalPendingClaims -= amount;
+    }
+}

package/src/protocol/UpgradeEntrypoint.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+
+import { Ownable2StepUpgradeable } from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
+
+import { IUpgradeEntrypoint } from "../interfaces/IUpgradeEntrypoint.sol";
+
+/**
+ * @title UpgradeEntrypoint
+ * @notice Entrypoint contract for submitting x/upgrade module actions.
+ */
+contract UpgradeEntrypoint is IUpgradeEntrypoint, Ownable2StepUpgradeable {
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the contract.
+    function initialize(address owner) public initializer {
+        require(owner != address(0), "UpgradeEntrypoint: owner cannot be zero address");
+        __Ownable_init(owner);
+    }
+
+    /// @notice Submits an upgrade plan.
+    /// @param name Sets the name for the upgrade. This name will be used by the upgraded version of the software to
+    /// apply any special "on-upgrade" commands during the first BeginBlock method after the upgrade is applied. It is
+    /// also used to detect whether a software version can handle a given upgrade. If no upgrade handler with this name
+    /// has been set in the software, it will be assumed that the software is out-of-date when the upgrade Time or
+    /// Height is reached and the software will exit.
+    /// @param height The height at which the upgrade must be performed.
+    /// @param info Any application specific upgrade info to be included on-chain such as a git commit that validators
+    /// could automatically upgrade to.
+    function planUpgrade(string calldata name, int64 height, string calldata info) external onlyOwner {
+        emit SoftwareUpgrade({ name: name, height: height, info: info });
+    }
+
+    /// @notice Cancels an upgrade plan if there is one planned. Otherwise, it does nothing.
+    function cancelUpgrade() external onlyOwner {
+        emit CancelUpgrade();
+    }
+}

package/src/token/WIP.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+
+import { ERC20 } from "solady/src/tokens/ERC20.sol";
+/// @notice Wrapped IP implementation.
+/// @author Inspired by WETH9 (https://github.com/dapphub/ds-weth/blob/master/src/weth9.sol)
+contract WIP is ERC20 {
+    /// @notice emitted when IP is deposited in exchange for WIP
+    event Deposit(address indexed from, uint amount);
+    /// @notice emitted when WIP is withdrawn in exchange for IP
+    event Withdrawal(address indexed to, uint amount);
+    /// @notice emitted when a transfer of IP fails
+    error IPTransferFailed();
+    /// @notice emitted when an invalid transfer recipient is detected
+    error ERC20InvalidReceiver(address receiver);
+    /// @notice emitted when an invalid transfer spender is detected
+    error ERC20InvalidSpender(address spender);
+
+    /// @notice triggered when IP is deposited in exchange for WIP
+    receive() external payable {
+        deposit();
+    }
+
+    /// @notice deposits IP in exchange for WIP
+    /// @dev the amount of IP deposited is equal to the amount of WIP minted
+    function deposit() public payable {
+        _mint(msg.sender, msg.value);
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    /// @notice withdraws WIP in exchange for IP
+    /// @dev the amount of IP minted is equal to the amount of WIP burned
+    /// @param value the amount of WIP to burn and withdraw
+    function withdraw(uint value) external {
+        _burn(msg.sender, value);
+        (bool success, ) = msg.sender.call{ value: value }("");
+        if (!success) {
+            revert IPTransferFailed();
+        }
+        emit Withdrawal(msg.sender, value);
+    }
+
+    /// @notice returns the name of the token
+    function name() public pure override returns (string memory) {
+        return "Wrapped IP";
+    }
+
+    /// @notice returns the symbol of the token
+    function symbol() public pure override returns (string memory) {
+        return "WIP";
+    }
+
+    /// @notice approves `spender` to spend `amount` of WIP
+    function approve(address spender, uint256 amount) public override returns (bool) {
+        if (spender == msg.sender) {
+            revert ERC20InvalidSpender(msg.sender);
+        }
+
+        return super.approve(spender, amount);
+    }
+
+    /// @notice transfers `amount` of WIP to a recipient `to`
+    function transfer(address to, uint256 amount) public override returns (bool) {
+        if (to == address(0)) {
+            revert ERC20InvalidReceiver(address(0));
+        }
+        if (to == address(this)) {
+            revert ERC20InvalidReceiver(address(this));
+        }
+
+        return super.transfer(to, amount);
+    }
+
+    /// @notice transfers `amount` of WIP from `from` to a recipient `to`
+    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
+        if (to == address(0)) {
+            revert ERC20InvalidReceiver(address(0));
+        }
+        if (to == address(this)) {
+            revert ERC20InvalidReceiver(address(this));
+        }
+
+        return super.transferFrom(from, to, amount);
+    }
+
+    /// @dev Sets Permit2 contract's allowance to infinity.
+    function _givePermit2InfiniteAllowance() internal pure override returns (bool) {
+        return true;
+    }
+}

package/test/data/ValidatorData.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+
+/* solhint-disable max-line-length */
+
+contract ValidatorData {
+    struct ValidatorInfo {
+        bytes uncompressedHex;
+        bytes compressedHex;
+        address evmAddress;
+    }
+
+    ValidatorInfo[] validators;
+
+    constructor() {
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"0481513466154dfc0e702d8325d7a45284bc395f60b813230da299fab640c1eb085a6e35cb30d41af355e4701f455447a675c497f98d38e783ba3f91bf75595a8f", // pragma: allowlist secret
+                compressedHex: hex"0381513466154dfc0e702d8325d7a45284bc395f60b813230da299fab640c1eb08", // pragma: allowlist secret
+                evmAddress: 0xb5cb887155446f69b5e4D11C30755108AC87e9cD
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04dd68a0a4923a1b9321d39f01425f7b631066514cb2e5e1b5ed91e5c327d30c534b55b55f63ca2ba7335f8086b955d93c25225986d8d8992675ce526fe720ecf1", // pragma: allowlist secret
+                compressedHex: hex"03dd68a0a4923a1b9321d39f01425f7b631066514cb2e5e1b5ed91e5c327d30c53", // pragma: allowlist secret
+                evmAddress: 0xf89D606F67a267E9dbCc813c8169988aB8aAeB5E
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04b95e0ff2299de8215fda840dcf37c9398296b0000773a7cf96e6814b979806acce72cb5239fd06f3d86c5ed409b3b5844182ceabb696835a9f9f2a9392ed2add", // pragma: allowlist secret
+                compressedHex: hex"03b95e0ff2299de8215fda840dcf37c9398296b0000773a7cf96e6814b979806ac", // pragma: allowlist secret
+                evmAddress: 0x7D42B46Cc15bC492C928950acD34E3A474305B8c
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04a5e10cd81da0bfe7644673fb349dea42d6b058b126a6dc81526561cc9d1680aae5b7adfaccba3c3c48d2b2ed637e6bc4eaca65da45b4ac57278c16daccf2dbbe", // pragma: allowlist secret
+                compressedHex: hex"02a5e10cd81da0bfe7644673fb349dea42d6b058b126a6dc81526561cc9d1680aa", // pragma: allowlist secret
+                evmAddress: 0xED0A0fb9d98a8C1d4D6E4A47241B79eEE982A42c
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04e40b0d98016dd26fdb19f446bc04739b3728f9e35ebf75b13584d745c9f360bc9adf8910018442f12fda19a323e321c6f7f68e68d13e27fb39edf667255a3efc", // pragma: allowlist secret
+                compressedHex: hex"02e40b0d98016dd26fdb19f446bc04739b3728f9e35ebf75b13584d745c9f360bc", // pragma: allowlist secret
+                evmAddress: 0x47F4fdC22191BB622a9Ea2645E684e12715D2512
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"048400994469b03d92a8c81949125c799a6d3ef26e4c16e200aec20a3f9fdd6a00ac491c3192fe316d71d866ed102c59c4fc0073f06226202e34e88ccec9bb8f9d", // pragma: allowlist secret
+                compressedHex: hex"038400994469b03d92a8c81949125c799a6d3ef26e4c16e200aec20a3f9fdd6a00", // pragma: allowlist secret
+                evmAddress: 0x9f6f533a1620f5c66539dF2dF3a2Ff3E93a36830
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"049d511cb4290718656a8eab48475d6127fc33acfc3e6f0415f5c4642d7766db554faef7531f593eff2c1c0eeb29881c094055a91a158526484a95c2f08e598d83", // pragma: allowlist secret
+                compressedHex: hex"039d511cb4290718656a8eab48475d6127fc33acfc3e6f0415f5c4642d7766db55", // pragma: allowlist secret
+                evmAddress: 0x54DA9dC7A141E86f6D5b8bb3Bd770f8d6F606DA7
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"046d6057a9982310f0d907edc08079912e09ca4dc843c80b26c1107262f11e1580b81db4439e93324309271730135a885d90b01e3a134da12bed39868cb4e9f94a", // pragma: allowlist secret
+                compressedHex: hex"026d6057a9982310f0d907edc08079912e09ca4dc843c80b26c1107262f11e1580", // pragma: allowlist secret
+                evmAddress: 0x53b9e8B9C04a6f6d4ae7BdAC759dE986083e7F0f
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04bfaa0a7de99fcca7702e00abff8bc9be4191bdd3b91d6900c4076c4bfdeb21f65793df6d75f88a7f5db5af53384c23c8f65d1406e251df74e72b18913ef48594", // pragma: allowlist secret
+                compressedHex: hex"02bfaa0a7de99fcca7702e00abff8bc9be4191bdd3b91d6900c4076c4bfdeb21f6", // pragma: allowlist secret
+                evmAddress: 0x82512864E8FECD296D228804F916601e925c97a3
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04761e5750ce3dd0cdca272572746151200a6216413f3a59681751d04ad4aeb46f78251d54d47dba45624d484d9c002ad007fa62180159bf0dfed6460a5a649765", // pragma: allowlist secret
+                compressedHex: hex"03761e5750ce3dd0cdca272572746151200a6216413f3a59681751d04ad4aeb46f", // pragma: allowlist secret
+                evmAddress: 0x89B59cDb363602006dA41f2e22DB180c08f08a8c
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"048f9ea6b774a6bb7b776f0d8a10a12d611118de57ed308bb14291668a4815f716976758014910c6e3f518aba17e11d7ee9cca8b91898ae991478557a08791d50f", // pragma: allowlist secret
+                compressedHex: hex"038f9ea6b774a6bb7b776f0d8a10a12d611118de57ed308bb14291668a4815f716", // pragma: allowlist secret
+                evmAddress: 0xedfe6037703C34cfF2caA52Dc36aD008cF494a8B
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04c4c09d9163b8a9fe1e64b94e203a632933ed5eecd8bd148c51d665fd75ff2d4afe8b1b2e58b5e5dacfc16b9ad233b9c7c172b35c7925b2ce58e21f9614e7ee06", // pragma: allowlist secret
+                compressedHex: hex"02c4c09d9163b8a9fe1e64b94e203a632933ed5eecd8bd148c51d665fd75ff2d4a", // pragma: allowlist secret
+                evmAddress: 0xa9C9cb27A16a2adE746fC88D92AE9Bac210d1D87
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"0479c448c6da7a8d5ee2eaa30318d4f5f9e7bde1d804d966d306cbc88e0e85bc0020a6f288651f51abf5caa47e7934de9f0e6dee0888ecb2624c054c4aef5079bf", // pragma: allowlist secret
+                compressedHex: hex"0379c448c6da7a8d5ee2eaa30318d4f5f9e7bde1d804d966d306cbc88e0e85bc00", // pragma: allowlist secret
+                evmAddress: 0x3AcB94A61A9AC3024e1302b8910f4fA1e647866C
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"0472ec9c47ae07959c59c92b83b03bd1cf393973a4ff9cafedb77e62be405c26d011d660c5caf70e06dbd4f015449ae3518fb99df1c11dc21ebedadc0170c3940f", // pragma: allowlist secret
+                compressedHex: hex"0372ec9c47ae07959c59c92b83b03bd1cf393973a4ff9cafedb77e62be405c26d0", // pragma: allowlist secret
+                evmAddress: 0x6c18582A638d0DFc4f7da3a4ED9f73FD10EFD5bd
+            })
+        );
+        validators.push(
+            ValidatorInfo({
+                uncompressedHex: hex"04ce0f23517b664591d061a3a3b5af80c3c887abbbbe54f47e3946f3f6405910a62a7b1ee97a6ea45c66aae8263ece2ded5c54ca7a598b6df6b219259a570d4e05", // pragma: allowlist secret
+                compressedHex: hex"03ce0f23517b664591d061a3a3b5af80c3c887abbbbe54f47e3946f3f6405910a6", // pragma: allowlist secret
+                evmAddress: 0xA6AB5320cC27c4643F946247D2f044946DECF050
+            })
+        );
+    }
+}

package/test/deploy/Create3.t.sol

@@ -0,0 +1,63 @@
+// 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 { Test } from "../utils/Test.sol";
+
+import { Create3 } from "../../src/deploy/Create3.sol";
+
+contract Create3Test is Test {
+    function testCreate3_deploy() public {
+        // deploy and getDeployed should return same address when deployed by the same deployer and with same salt.
+        bytes32 salt = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
+        bytes memory creationCode = type(Create3).creationCode;
+        address deployed = create3.deploy(salt, creationCode);
+        address expected = create3.getDeployed(address(this), salt);
+        assertEq(deployed, expected);
+
+        // Network shall generate the same address for the same deployer and salt.
+        vm.expectRevert("DEPLOYMENT_FAILED");
+        deployed = create3.deploy(salt, creationCode);
+
+        // Network shall generate different addresses for different deployers.
+        address otherAddr = address(0xf398C12A45Bc409b6C652E25bb0a3e702492A4ab);
+        vm.prank(otherAddr);
+        deployed = create3.deploy(salt, creationCode);
+        expected = create3.getDeployed(otherAddr, salt);
+        assertEq(deployed, expected);
+
+        // Network shall generate different addresses for different salts.
+        bytes32 otherSalt = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890fedcba;
+        deployed = create3.deploy(otherSalt, creationCode);
+        expected = create3.getDeployed(address(this), otherSalt);
+        assertEq(deployed, expected);
+    }
+
+    function testCreate3_deploy_onlySalt() public {
+        // deployDeterministic and predictDeterministicAddress return same address when deployed by the same salt.
+        bytes32 salt = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
+        bytes memory creationCode = type(Create3).creationCode;
+        address deployed = create3.deployDeterministic(creationCode, salt);
+        address expected = create3.predictDeterministicAddress(salt);
+        assertEq(deployed, expected);
+
+        // Network shall generate the same address for the same salt.
+        vm.expectRevert("DEPLOYMENT_FAILED");
+        deployed = create3.deployDeterministic(creationCode, salt);
+
+        // Network shall generate same addresses for different deployers.
+        address otherAddr = address(0xf398C12A45Bc409b6C652E25bb0a3e702492A4ab);
+        vm.prank(otherAddr);
+        vm.expectRevert("DEPLOYMENT_FAILED");
+        deployed = create3.deployDeterministic(creationCode, salt);
+
+        // Network shall generate different addresses for different salts.
+        bytes32 otherSalt = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890fedcba;
+        deployed = create3.deployDeterministic(creationCode, otherSalt);
+        expected = create3.predictDeterministicAddress(otherSalt);
+        assertEq(deployed, expected);
+    }
+}

package/test/erc6551/Erc6551Registry.t.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+
+import { Test } from "../utils/Test.sol";
+/* 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
+
+contract ERC6551RegistryTest is Test {
+    function test_erc6551Registry() public {
+        address account = erc6551Registry.createAccount(
+            address(this),
+            0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef,
+            block.chainid,
+            address(this),
+            1
+        );
+
+        assertNotEq(account, address(0));
+
+        assertEq(
+            account,
+            erc6551Registry.account(
+                address(this),
+                0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef,
+                block.chainid,
+                address(this),
+                1
+            )
+        );
+    }
+}

package/test/secp256k/Secp256k1PubKeyVerifier.t.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.8.23;
+/* solhint-disable no-console */
+/* solhint-disable max-line-length */
+/* solhint-disable function-state-mutability */
+/// 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 { Test } from "forge-std/Test.sol";
+
+import { Secp256k1Verifier } from "../../src/protocol/Secp256k1Verifier.sol";
+
+contract Secp256k1VerifierHarness is Secp256k1Verifier {
+    function uncompressPublicKey(bytes memory compressedKey) public pure returns (bytes memory) {
+        return _uncompressPublicKey(compressedKey);
+    }
+}
+
+contract Secp256k1VerifierTest is Test {
+    Secp256k1VerifierHarness public verifier;
+
+    function setUp() public {
+        verifier = new Secp256k1VerifierHarness();
+    }
+
+    function testCompressPublicKey_validKey() public view {
+        // prefix: 04
+        bytes
+            memory uncmpPubkey = hex"04ed58a9319aba87f60fe08e87bc31658dda6bfd7931686790a2ff803846d4e59c215b515f2acba1de2979c9b1376e088d4e48b20331a876ae4ed2c4f6bafc4016"; // pragma: allowlist-secret
+        // prefix: 03
+        bytes memory cmpPubkey = hex"02ed58a9319aba87f60fe08e87bc31658dda6bfd7931686790a2ff803846d4e59c"; // pragma: allowlist-secret
+
+        bytes memory anotherCmpPubkey = hex"037ff1214f5af4b652bc6c352ecb1296791cf754a426b49a7c4a263124f7497e98"; // pragma: allowlist-secret
+
+        vm.assertEq(verifier.uncompressPublicKey(cmpPubkey), uncmpPubkey);
+        vm.assertNotEq(verifier.uncompressPublicKey(cmpPubkey), verifier.uncompressPublicKey(anotherCmpPubkey));
+    }
+
+    function testCompressPublicKey_deriveAddress() public pure {
+        // prefix 04 sliced from `04e38d15ae6cc5d41cce27a2307903cb12a406cbf463fe5fef215bdf8aa988ced195e9327ac89cd362eaa0397f8d7f007c02b2a75642f174e455d339e4a1efe47b` // pragma: allowlist-secret
+        bytes
+            memory uncmpPubkeySliced = hex"e38d15ae6cc5d41cce27a2307903cb12a406cbf463fe5fef215bdf8aa988ced195e9327ac89cd362eaa0397f8d7f007c02b2a75642f174e455d339e4a1efe47b"; // pragma: allowlist-secret
+
+        address expectedAddr = 0xf398C12A45Bc409b6C652E25bb0a3e702492A4ab;
+        address derivedAddr = address(uint160(uint256(keccak256(uncmpPubkeySliced))));
+
+        vm.assertEq(uncmpPubkeySliced.length, 64);
+        vm.assertEq(derivedAddr, expectedAddr);
+    }
+}