Skip to content

Commit

Permalink
fix: ci
Browse files Browse the repository at this point in the history
  • Loading branch information
@0xClandestine
0xClandestine committed Feb 13, 2025
1 parent ccca498 commit 7b277d2
Show file tree
Hide file tree
Showing 2 changed files with 110 additions and 41 deletions.
110 changes: 80 additions & 30 deletions src/test/unit/libraries/BytesLibUnit.t.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,86 +4,136 @@ pragma solidity ^0.8.27;
import "forge-std/Test.sol";
import "src/contracts/libraries/BytesLib.sol";

contract BytesLibHarness {
function concat(bytes memory a, bytes memory b) public pure returns (bytes memory) {
return BytesLib.concat(a, b);
}

function slice(bytes memory data, uint256 start, uint256 length) public pure returns (bytes memory) {
return BytesLib.slice(data, start, length);
}

function toAddress(bytes memory data, uint256 offset) public pure returns (address) {
return BytesLib.toAddress(data, offset);
}

function toUint256(bytes memory data, uint256 offset) public pure returns (uint256) {
return BytesLib.toUint256(data, offset);
}

function toUint128(bytes memory data, uint256 offset) public pure returns (uint128) {
return BytesLib.toUint128(data, offset);
}

function toUint96(bytes memory data, uint256 offset) public pure returns (uint96) {
return BytesLib.toUint96(data, offset);
}

function toUint64(bytes memory data, uint256 offset) public pure returns (uint64) {
return BytesLib.toUint64(data, offset);
}

function toUint32(bytes memory data, uint256 offset) public pure returns (uint32) {
return BytesLib.toUint32(data, offset);
}

function toUint16(bytes memory data, uint256 offset) public pure returns (uint16) {
return BytesLib.toUint16(data, offset);
}

function toUint8(bytes memory data, uint256 offset) public pure returns (uint8) {
return BytesLib.toUint8(data, offset);
}

function equal(bytes memory a, bytes memory b) public pure returns (bool) {
return BytesLib.equal(a, b);
}
}

contract BytesLibUnitTests is Test {
using BytesLib for bytes;
BytesLibHarness harness;

function setUp() public {
harness = new BytesLibHarness();
}

function test_Concat_Basic() public pure {
function test_Concat_Basic() public view {
bytes memory a = hex"1234";
bytes memory b = hex"5678";
bytes memory expected = hex"12345678";

bytes memory result = a.concat(b);
assertTrue(result.equal(expected));
bytes memory result = harness.concat(a, b);
assertTrue(harness.equal(result, expected));
}

function test_Concat_EmptyInputs() public pure {
function test_Concat_EmptyInputs() public view {
bytes memory empty = hex"";
bytes memory data = hex"1234";

assertTrue(empty.concat(empty).equal(empty));
assertTrue(data.concat(empty).equal(data));
assertTrue(empty.concat(data).equal(data));
assertTrue(harness.equal(harness.concat(empty, empty), empty));
assertTrue(harness.equal(harness.concat(data, empty), data));
assertTrue(harness.equal(harness.concat(empty, data), data));
}

function test_Slice_Basic() public pure {
function test_Slice_Basic() public view {
bytes memory data = hex"0123456789";
bytes memory expected = hex"234567";

bytes memory result = data.slice(1, 3);
assertTrue(result.equal(expected));
bytes memory result = harness.slice(data, 1, 3);
assertTrue(harness.equal(result, expected));
}

function test_Revert_SliceOutOfBounds() public {
bytes memory data = hex"0123456789";

// Test start beyond length
vm.expectRevert(BytesLib.OutOfBounds.selector);
data.slice(10, 1);
harness.slice(data, 10, 1);

// Test length beyond data bounds
vm.expectRevert(BytesLib.OutOfBounds.selector);
data.slice(0, 11);
harness.slice(data, 0, 11);

// Test start + length beyond bounds
vm.expectRevert(BytesLib.OutOfBounds.selector);
data.slice(5, 6);
harness.slice(data, 5, 6);
}

function test_ToAddress() public pure {
function test_ToAddress() public view {
bytes memory data = hex"000000000000000000000000A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
address expected = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;

assertEq(data.toAddress(12), expected);
assertEq(harness.toAddress(data, 12), expected);
}

function test_ToUint() public pure {
function test_ToUint() public view {
bytes memory data = hex"000000000000000000000000000000000000000000000000000000000000002A";

assertEq(data.toUint256(0), 42);
assertEq(data.toUint8(31), 42);
assertEq(data.toUint16(30), 42);
assertEq(data.toUint32(28), 42);
assertEq(data.toUint64(24), 42);
assertEq(data.toUint96(20), 42);
assertEq(data.toUint128(16), 42);
assertEq(harness.toUint256(data, 0), 42);
assertEq(harness.toUint8(data, 31), 42);
assertEq(harness.toUint16(data, 30), 42);
assertEq(harness.toUint32(data, 28), 42);
assertEq(harness.toUint64(data, 24), 42);
assertEq(harness.toUint96(data, 20), 42);
assertEq(harness.toUint128(data, 16), 42);
}

function test_Equal() public pure {
function test_Equal() public view {
bytes memory a = hex"1234567890";
bytes memory b = hex"1234567890";
bytes memory c = hex"1234567891";

assertTrue(a.equal(b));
assertFalse(a.equal(c));
assertTrue(harness.equal(a, b));
assertFalse(harness.equal(a, c));
}

function test_Revert_ToTypesOutOfBounds() public {
bytes memory tooShort = hex"1234";

vm.expectRevert(BytesLib.OutOfBounds.selector);
tooShort.toAddress(0);
harness.toAddress(tooShort, 0);

vm.expectRevert(BytesLib.OutOfBounds.selector);
tooShort.toUint256(0);
harness.toUint256(tooShort, 0);
}
}
}
41 changes: 30 additions & 11 deletions src/test/unit/mixins/SignatureUtilsUnit.t.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,24 @@ contract MockSigner {
}
}

contract SignatureUtilsUnit is Test, SignatureUtils {
contract SignatureUtilsHarness is SignatureUtils {
function calculateSignableDigest(bytes32 hash) public view returns (bytes32) {
return _calculateSignableDigest(hash);
}

function checkIsValidSignatureNow(
address signer,
bytes32 digest,
bytes memory signature,
uint256 expiry
) public view {
_checkIsValidSignatureNow(signer, digest, signature, expiry);
}
}

contract SignatureUtilsUnit is Test {
SignatureUtilsHarness harness;
MockSigner mockSigner;
uint256 signerPk;
address signer;
bytes32 hash;
Expand All @@ -26,35 +43,36 @@ contract SignatureUtilsUnit is Test, SignatureUtils {
function setUp() public {
vm.chainId(1);

harness = new SignatureUtilsHarness();
mockSigner = new MockSigner();
signerPk = 1;
signer = vm.addr(signerPk);

hash = keccak256("");
digest = _calculateSignableDigest(hash);
digest = harness.calculateSignableDigest(hash);

expectedDomainSeparator = keccak256(
abi.encode(
keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"),
keccak256(bytes("EigenLayer")),
block.chainid,
address(this)
address(harness)
)
);
}

function test_domainSeparator_NonZero() public view {
assertTrue(_INITIAL_DOMAIN_SEPARATOR != 0, "The initial domain separator should be non-zero");
assertTrue(domainSeparator() != 0, "The domain separator should be non-zero");
assertTrue(domainSeparator() == expectedDomainSeparator, "The domain separator should be as expected");
assertTrue(harness.domainSeparator() != 0, "The domain separator should be non-zero");
assertTrue(harness.domainSeparator() == expectedDomainSeparator, "The domain separator should be as expected");
}

function test_domainSeparator_NewChainId() public {
bytes32 initialDomainSeparator = domainSeparator();
bytes32 initialDomainSeparator = harness.domainSeparator();

// Change the chain ID
vm.chainId(9999);

bytes32 newDomainSeparator = domainSeparator();
bytes32 newDomainSeparator = harness.domainSeparator();

assertTrue(newDomainSeparator != 0, "The new domain separator should be non-zero");
assertTrue(
Expand All @@ -67,10 +85,11 @@ contract SignatureUtilsUnit is Test, SignatureUtils {
(uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPk, digest);

vm.expectRevert(ISignatureUtils.SignatureExpired.selector);
_checkIsValidSignatureNow(signer, digest, abi.encode(r, s, v), block.timestamp - 1);
harness.checkIsValidSignatureNow(signer, digest, abi.encode(r, s, v), block.timestamp - 1);
}

function testFail_checkIsValidSignatureNow_InvalidSignature() public view {
_checkIsValidSignatureNow(signer, digest, "", block.timestamp);
function test_Revert_checkIsValidSignatureNow_InvalidSignature() public {
vm.expectRevert(ISignatureUtils.InvalidSignature.selector);
harness.checkIsValidSignatureNow(signer, digest, "", block.timestamp);
}
}

0 comments on commit 7b277d2

Please sign in to comment.