프로그램

struct Ed25519SignatureOffsets {
    signature_offset: u16,             // 명령어 데이터 내 서명의 오프셋
    signature_instruction_index: u16,  // 트랜잭션 내 명령어 인덱스
    public_key_offset: u16,            // 명령어 데이터 내 공개 키의 오프셋
    public_key_instruction_index: u16, // 트랜잭션 내 명령어 인덱스
    message_offset: u16,               // 명령어 데이터 내 메시지의 오프셋
    message_instruction_index: u16,    // 트랜잭션 내 명령어 인덱스
    message_data_size: u16,            // 메시지 데이터의 크기
}

for i in 0..num_signatures {
    let offset = ed25519_signature_offsets[i];

    // 서명 가져오기
    let signature = get_signature_from(
        transaction,
        offset.signature_instruction_index,
        offset.signature_offset
    );

    // 공개 키 가져오기
    let public_key = get_public_key_from(
        transaction,
        offset.public_key_instruction_index,
        offset.public_key_offset
    );

    // 메시지 가져오기
    let message = get_message_from(
        transaction,
        offset.message_instruction_index,
        offset.message_offset,
        offset.message_data_size
    );

    // 서명 검증
    if !ed25519::verify(message, public_key, signature) {
        return Error;
    }
}

struct Secp256k1SignatureOffsets {
    signature_offset: u16,             // 명령어 데이터 내 서명의 오프셋
    signature_instruction_index: u16,  // 트랜잭션 내 명령어 인덱스
    eth_address_offset: u16,           // 명령어 데이터 내 이더리움 주소의 오프셋
    eth_address_instruction_index: u16,// 트랜잭션 내 명령어 인덱스
    message_offset: u16,               // 명령어 데이터 내 메시지의 오프셋
    message_instruction_index: u16,    // 트랜잭션 내 명령어 인덱스
    message_data_size: u16,            // 메시지 데이터의 크기
}

for i in 0..num_signatures {
    let offset = secp256k1_signature_offsets[i];

    // 서명 가져오기
    let signature = get_signature_from(
        transaction,
        offset.signature_instruction_index,
        offset.signature_offset
    );

    // 이더리움 주소 가져오기
    let eth_address = get_eth_address_from(
        transaction,
        offset.eth_address_instruction_index,
        offset.eth_address_offset
    );

    // 메시지 가져오기
    let message = get_message_from(
        transaction,
        offset.message_instruction_index,
        offset.message_offset,
        offset.message_data_size
    );

    // 서명에서 공개 키 복구
    let recovered_key = secp256k1::recover(message, signature);

    // 복구된 키에서 이더리움 주소 계산
    let calculated_address = keccak256(recovered_key)[12..32];

    // 주소 검증
    if eth_address != calculated_address {
        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
}