cyotee/forge-signing

Foundry Signing Cheatcodes

Sign messages for testing signature verification in Solidity contracts.

Import

import {Vm} from "forge-std/Vm.sol";
Vm constant vm = Vm(VM_ADDRESS);

sign(uint256 privateKey, bytes32 digest)

Sign a digest with a private key:

(uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);

Returns:

• v - Recovery id
• r - First 32 bytes of signature
• s - Second 32 bytes of signature

sign(Wallet memory wallet, bytes32 digest)

Using a Wallet struct:

Wallet memory wallet = vm.createWallet("alice");
(uint8 v, bytes32 r, bytes32 s) = vm.sign(wallet, digest);

Basic Example: Sign and Recover

(address alice,) = makeAddrAndKey("alice");
bytes32 hash = keccak256("Signed by Alice");

(uint8 v, bytes32 r, bytes32 s) = vm.sign(alicePk, hash);
address signer = ecrecover(hash, v, r, s);

assertEq(alice, signer); // PASS

Testing EIP-712 Signatures

function testEIP712Signature() public {
    (address alice, uint256 alicePk) = makeAddrAndKey("alice");
    
    // Build EIP-712 domain separator
    bytes32 domainSeparator = keccak256(abi.encode(
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
        keccak256("MyContract"),
        keccak256("1"),
        block.chainid,
        address(this)
    ));
    
    // Build typed data hash
    bytes32 structHash = keccak256(abi.encode(
        keccak256("Message(address sender,uint256 amount)"),
        alice,
        100e18
    ));
    
    bytes32 digest = keccak256(abi.encodePacked(
        "\x19\x01",
        domainSeparator,
        structHash
    ));
    
    // Sign
    (uint8 v, bytes32 r, bytes32 s) = vm.sign(alicePk, digest);
    bytes memory signature = abi.encodePacked(r, s, v);
    
    // Verify in contract
    assertTrue(verifySignature(alice, digest, signature));
}

Testing Permit2 Signatures

function testPermit2Signature() public {
    (address alice, uint256 alicePk) = makeAddrAndKey("alice");
    
    // Build permit data (matching Permit2's expected format)
    bytes32 digest = // ... build according to Permit2 spec
    
    (uint8 v, bytes32 r, bytes32 s) = vm.sign(alicePk, digest);
    bytes memory signature = abi.encodePacked(r, s, v);
    
    // Call contract that verifies Permit2 signature
    router.swapSingleTokenExactInWithPermit(..., signature);
}

Gotcha: Signature Byte Order

When encoding for OpenZeppelin's ECDSA library:

// WRONG:
bytes memory signature = abi.encodePacked(v, r, s);

// CORRECT:
bytes memory signature = abi.encodePacked(r, s, v);

OpenZeppelin expects (r, s, v) order, not (v, r, s).

Related Cheatcodes

| Cheatcode | Purpose | |-----------|---------| | vm.addr(uint256) | Get address from private key | | vm.createWallet(string) | Create Wallet struct | | vm.createWallet(string, uint256) | Create wallet with specific key | | vm.sign(Wallet, bytes32) | Sign with Wallet struct |