Verify EIP-1271 Signature

WHAT IT DOES

Verify EIP-1271 Signature enables you to validate cryptographic signatures against EIP-1271-compliant smart contracts. EIP-1271 defines a standard for contracts to verify signatures, enabling smart contract wallets (like Gnosis Safe, ERC-4337 accounts, and multisig wallets) to produce verifiable signatures off-chain. Unlike EOA signatures that are recovered directly from the signature, contract signatures must be verified by calling the contract's isValidSignature() function, which implements the contract's own validation logic. This tool reads your connected wallet address for context, lets you specify the contract address that will verify the signature, the message hash that was signed, and the signature bytes to check. It then calls the contract's isValidSignature() function on-chain and compares the returned magic value against the EIP-1271 standard magic value (0x1626ba7e). The tool displays the verification result clearly, indicating whether the signature is valid or invalid.

HOW TO USE

Connect your wallet using the BGWallet connector. Select the network where the contract is deployed—the contract must be on the same network as your connected wallet. Enter the contract address that implements EIP-1271 and will verify the signature (e.g., a Gnosis Safe, a multisig wallet, or an ERC-4337 smart account). Enter the message hash (as a 32-byte hex string starting with 0x) that was signed. Enter the signature bytes (as a hex string starting with 0x) to verify. The tool validates that the contract exists at the address provided and that the call to isValidSignature() succeeds. After clicking "Verify signature", the tool makes an on-chain view call to isValidSignature(), checks the return value, and displays the result. The review panel shows the contract address, message hash, signature, and the verification result. If valid, a green checkmark appears; if invalid, a red X appears with a clear error explanation.

TECHNICAL MECHANISM

This tool implements EIP-1271 signature verification by calling the contract's isValidSignature(bytes32 hash, bytes memory signature) function. EIP-1271 requires that this function returns the magic value 0x1626ba7e if the signature is valid, and any other value (often 0xffffffff) if invalid. The tool first checks that the contract exists at the provided address using getCode() to prevent calls to non-existent contracts. It then constructs a read-only call to isValidSignature() using the provided message hash and signature. If the call reverts, the tool catches the error and reports it, indicating that the contract may not support EIP-1271 or the parameters are invalid. The tool compares the returned bytes4 value against the standard magic value. The result is displayed with clear visual feedback: green for valid (0x1626ba7e) and red for invalid or error states. The tool does not require gas for verification since it uses a view function (read-only). This makes it cheap and fast to verify signatures as many times as needed.

WHAT IT CANNOT SEE

This tool cannot verify signatures for contracts that do not implement EIP-1271—the call will revert or return an invalid magic value. It does not support dynamic or non-standard verification logic variations that deviate from the standard EIP-1271 interface. The tool cannot verify signatures for messages that were not hashed according to the contract's expectations; if the message was hashed with a different scheme, the verification will fail. It cannot recover or modify the signature if invalid; the signature is cryptographically fixed. The tool does not verify that the contract address is actually a smart contract beyond checking if code exists at the address. It cannot guarantee that the verification result is final if the contract's verification logic can change, such as with upgradeable contracts where the implementation can be changed. The tool does not support EIP-1271 versions with custom verification parameters beyond the standard hash and signature parameters.

PLEASE NOTE

This tool works only on EVM-compatible chains that support the EIP-1271 standard. The contract address must be a smart contract that implements the isValidSignature() function with the exact EIP-1271 signature. The message hash must be the raw bytes32 hash that was signed—it should not include the standard Ethereum signed message prefix (as used in personal_sign), unless the contract expects that format. The signature should be in the format expected by the contract (typically concatenated r, s, v bytes, 65 bytes total). For contracts like Gnosis Safe, the signature may include additional bytes for owner validation. The tool is read-only and does not submit any transactions, so there is no gas cost for the verification itself. Always ensure that the contract address and network match the context where the signature was intended to be used.