EIP-7932 - Secondary Signature Algorithms

trait Algorithm {
    // The algorithm type byte
    ALG_TYPE: uint8,

    // The size of signatures. Signatures MUST be padded
    // to this size to be valid. Note that this does include
    // the ALG_TYPE byte prefix
    SIZE: uint32

    // Get the gas cost of signing this data. This
    // SHOULD include a reasonable minimum and MUST
    // be relative to secp256k1, i.e. 0 gas is secp256k1.
    fn gas_cost(signing_data: Bytes) -> Uint64;

    // Check whether the signature is valid. For some
    // algorithms, this may be a no-op. This function
    // will always be called before `verify`.
    fn validate(signature: Bytes) -> None | Error;

    // Take the signature and signing_data and return the
    // public key of the signer.
    fn verify(signature: Bytes, signing_data: Bytes) -> Bytes | Error;
}

def pubkey_to_address(public_key: Bytes, algorithm_id: uint8) -> ExecutionAddress:
    if algorithm_id == 0xFF: # Compatibility shim to ensure backwards compatibility
        return ExecutionAddress(keccak(public_key[1:])[12:])

    # with `||` being binary concatenation
    return ExecutionAddress(keccak(algorithm_id || public_key)[12:])

class AlgorithmEntry():
    ALG_TYPE: uint8,
    SIZE: uint32,
    gas_cost: Callable[[Bytes], uint64],
    validate: Callable[[Bytes], None | Error],
    verify: Callable[[Bytes, Bytes], Bytes | Error]

algorithm_registry: Dict[uint8, AlgorithmEntry]

def calculate_penalty(algorithm: uint8, signing_data: Bytes) -> uint:
    assert algorithm in algorithm_registry

    algorithm = algorithm_registry[algorithm]

    return algorithm.gas_cost(signing_data)

def validate_signature(signature: Bytes):
    assert len(signature) > 0
    assert signature[0] in algorithm_registry

    algorithm = algorithm_registry[signature[0]]

    return algorithm.validate(signature)

# This function cannot be called without prior calling `validate_signature(signature)`
def verify_signature(signing_data: Bytes, signature: Bytes) -> Bytes:
    algorithm = algorithm_registry[signature[0]]

    return algorithm.verify(signature, signing_data)

ALG_TYPE = 0xFF
SIZE = 

SECP256K1_SIGNATURE_SIZE = SIZE - 1

def secp256k1_unpack(signature: ByteVector[SECP256K1_SIGNATURE_SIZE]) -> tuple[uint256, uint256, uint8]:
    r = uint256.from_bytes(signature[0:32], 'big')
    s = uint256.from_bytes(signature[32:64], 'big')
    y_parity = signature[64]
    return (r, s, y_parity)

def secp256k1_validate(signature: ByteVector[SECP256K1_SIGNATURE_SIZE]):
    SECP256K1N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
    r, s, y_parity = secp256k1_unpack(signature)
    assert 0 < r < SECP256K1N
    assert 0 < s <= SECP256K1N // 2
    assert y_parity in (0, 1)

def gas_cost(signing_data: Bytes) -> Uint64:
    # This is an adaptation from the KECCAK256 opcode
    if len(signing_data) == 32:
        return Uint64(0)
    else:
        minimum_word_size = (len(signing_data) + 31) // 32
        return Uint64(30 + (6 * minimum_word_size))

def validate(signature: Bytes) -> None | Error:
    secp256k1_validate(signature[1:])

def verify(signature: Bytes, signing_data: Bytes) -> Bytes | Error:
    # Another compatibility shim to ensure passing a 32 byte hash still works.
    if len(signing_data) != 32:
        signing_data = keccak256(signing_data)

    ecdsa = ECDSA()
    recover_sig = ecdsa.ecdsa_recoverable_deserialize(signature[1:65], signature[65])
    public_key = PublicKey(ecdsa.ecdsa_recover(signing_data, recover_sig, raw=True))
    uncompressed = public_key.serialize(compressed=False)
    return uncompressed

def sigrecover_precompile(input: Bytes) -> Bytes:
    assert len(input) >= 1
    assert input[0] in algorithm_registry

    size = algorithm_registry[input[0]].SIZE

    assert len(input) > size

    signature = input[:size]
    signing_data = input[size:]

    charge_gas(calculate_penalty(input[0], signing_data))

    # Run validate/verify function
    validate_signature(signature)
    pubkey = verify_signature(signing_data, signature)

    return pubkey_to_address(pubkey, input[0])