Program

struct Ed25519SignatureOffsets {
    signature_offset: u16,             // offset to ed25519 signature of 64 bytes
    signature_instruction_index: u16,  // instruction index to find signature
    public_key_offset: u16,            // offset to public key of 32 bytes
    public_key_instruction_index: u16, // instruction index to find public key
    message_data_offset: u16,          // offset to start of message data
    message_data_size: u16,            // size of message data
    message_instruction_index: u16,    // index of instruction data to get message data
}

for i in 0..signatures_count {
    let Ed25519SignatureOffsets {
        signature_offset,
        signature_instruction_index,
        public_key_offset,
        public_key_instruction_index,
        message_data_offset,
        message_data_size,
        message_instruction_index,
    } = ...; // Deserialize from instruction

    // Signature, pubkey and message data can be loaded from any instruction in the transaction
    let signature = instruction_at(signature_instruction_index).data(signature_offset..signature_offset + 64);
    let pubkey = instruction_at(public_key_instruction_index).data(public_key_offset..public_key_offset + 32);
    let message = instruction_at(message_instruction_index).data(message_data_offset..message_data_offset + message_data_size);
    if !ed25519::verify(pubkey, message, signature) {
        return Error;
    }
}

struct Secp256k1SignatureOffsets {
    signature_offset: u16,             // offset to secp256k1 signature
    signature_instruction_index: u16,  // instruction index to find signature
    eth_address_offset: u16,           // offset to eth_address
    eth_address_instruction_index: u16, // instruction index to find eth_address
    message_data_offset: u16,          // offset to start of message data
    message_data_size: u16,            // size of message data
    message_instruction_index: u16,    // index of instruction data to get message data
}

for i in 0..count {
    let Secp256k1SignatureOffsets {
        signature_offset,
        signature_instruction_index,
        eth_address_offset,
        eth_address_instruction_index,
        message_data_offset,
        message_data_size,
        message_instruction_index,
    } = ...; // Deserialize from instruction

    // Signature, eth_address and message data can be loaded from any instruction in the transaction
    let signature = instruction_at(signature_instruction_index).data(signature_offset..signature_offset + 64);
    let eth_address = instruction_at(eth_address_instruction_index).data(eth_address_offset..eth_address_offset + 20);
    let message = instruction_at(message_instruction_index).data(message_data_offset..message_data_offset + message_data_size);

    // construct the message that was signed
    let mut signing_message = format!("\x19Ethereum Signed Message:\n{}", message.len());
    signing_message.extend(message);
    let message_hash = keccak256(&signing_message);

    // recover the public key
    let recovered_key = secp256k1_recover(signature, message_hash);
    let eth_address_recovered = keccak256(recovered_key);

    // check that the recovered key matches the given eth_address
    if eth_address != eth_address_recovered {
        return Error;
    }
}

struct Secp256r1SignatureOffsets {
    signature_offset: u16,             // offset to compact secp256r1 signature of 64 bytes
    signature_instruction_index: u16,  // instruction index to find signature
    public_key_offset: u16,            // offset to compressed public key of 33 bytes
    public_key_instruction_index: u16, // instruction index to find public key
    message_data_offset: u16,          // offset to start of message data
    message_data_size: u16,            // size of message data
    message_instruction_index: u16,    // index of instruction data to get message data
}

process_instruction() {
    if data.len() < SIGNATURE_OFFSETS_START {
        return Error
    }

    num_signatures = data[0] as usize
    if num_signatures == 0 || num_signatures > 8 {
        return Error
    }

    expected_data_size = num_signatures * SIGNATURE_OFFSETS_SERIALIZED_SIZE + SIGNATURE_OFFSETS_START
    if data.len() < expected_data_size {
        return Error
    }

    for i in 0..num_signatures {
        offsets = parse_signature_offsets(data, i)

        signature = get_data_slice(data, instruction_datas, offsets.signature_instruction_index, offsets.signature_offset, SIGNATURE_SERIALIZED_SIZE)

        if s > half_curve_order {
            return Error
        }

        pubkey = get_data_slice(data, instruction_datas, offsets.public_key_instruction_index, offsets.public_key_offset, COMPRESSED_PUBKEY_SERIALIZED_SIZE)

        message = get_data_slice(data, instruction_datas, offsets.message_instruction_index, offsets.message_data_offset, offsets.message_data_size)

        if !verify_signature(signature, pubkey, message) {
            return Error
        }
    }

    return Success
}