EVM Integration

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

/**
 * @title SignatureVerifier
 * @dev Contract to verify signatures generated by the ChaosLabs Oracle API
 * using OpenZeppelin's ECDSA library
 */
contract SignatureVerifier {
    using ECDSA for bytes32;

    /**
     * @dev Verifies if a signature was signed by the expected signer
     * @param messageHash The hash of the message that was signed
     * @param signature The signature bytes (65 bytes - r, s, v)
     * @param signer The expected signer address
     * @return bool True if the signature is valid, false otherwise
     */
    function verifySignature(
        bytes32 messageHash,
        bytes calldata signature,
        address signer
    ) external pure returns (bool) {
        address recoveredSigner = messageHash.recover(signature);
        return recoveredSigner == signer;
    }

    /**
     * @dev Hashes an oracle price feed data using the same method as in chain_signatures.go
     * @param feedId The feed ID (should already be adjusted, e.g., "BTCUSD")
     * @param price The price value
     * @param expo The exponent value (int8)
     * @param roundId The round ID
     * @param timestamp The timestamp
     * @param bid Optional bid value (set to 0 if not used)
     * @param ask Optional ask value (set to 0 if not used)
     * @return bytes32 The keccak256 hash of the encoded data
     */
    function hashPriceFeedData(
        string memory feedId,
        uint256 price,
        int8 expo,
        uint256 roundId,
        uint256 timestamp,
        uint256 bid,
        uint256 ask
    ) public pure returns (bytes32) {
        bytes memory message;

        // Go's big.NewInt(int64(expo)).Bytes() returns absolute value as minimal bytes
        // For expo = -8, big.NewInt(-8).Bytes() returns [8] (absolute value)
        // For expo = 0, big.NewInt(0).Bytes() returns [] (empty slice)
        bytes memory expoBytes;
        if (expo == 0) {
            expoBytes = new bytes(0); // Empty slice for zero
        } else {
            // Use absolute value, same as Go's big.Int.Bytes() behavior
            uint8 absExpo = expo < 0 ? uint8(-expo) : uint8(expo);
            expoBytes = abi.encodePacked(absExpo);
        }

        // Round ID is passed as bytes in Go, convert uint256 to bytes here
        bytes memory roundIdBytes = abi.encodePacked(roundId);

        message = abi.encodePacked(
            keccak256(bytes(feedId)),
            leftPadBytes(abi.encodePacked(price), 32),
            leftPadBytes(expoBytes, 32),
            leftPadBytes(roundIdBytes, 32),
            leftPadBytes(abi.encodePacked(timestamp), 32),
            leftPadBytes(abi.encodePacked(bid), 32),
            leftPadBytes(abi.encodePacked(ask), 32)
        );

        return keccak256(message);
    }

    /**
     * @dev Left pads a byte array to the specified length, matching Go's common.LeftPadBytes
     * @param data The input bytes
     * @param length The desired output length
     * @return bytes The left-padded bytes
     */
    function leftPadBytes(bytes memory data, uint256 length)
        public
        pure
        returns (bytes memory)
    {
        if (data.length >= length) {
            return data;
        }

        bytes memory result = new bytes(length);
        uint256 paddingLength = length - data.length;

        for (uint256 i = 0; i < data.length; i++) {
            result[paddingLength + i] = data[i];
        }

        return result;
    }
}