// file: crates/ksp-raw-transaction-lib/tests/public_api.rs
// version: 5

//! Integration canaries for the public common RAW Transaction crate-root surface.

#[test]
fn pre_002_common_raw_contract_is_consumable_from_crate_root() {
    assert_eq!(ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_ID, "ksp.solana.raw_transaction");
    assert_eq!(ksp_raw_transaction_lib::RAW_TRANSACTION_FORMAT_VERSION, 1);
    assert_eq!(ksp_raw_transaction_lib::MIN_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES, 64);
    assert_eq!(ksp_raw_transaction_lib::MAX_RAW_TRANSACTION_SIGNATURE_TEXT_BYTES, 88);
    let network = match ksp_store_api::RawNetworkId::new("devnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let signature = match ksp_raw_transaction_lib::parse_raw_transaction_signature("1".repeat(64).as_str()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
        network,
        signature,
        5,
        std::option::Option::None,
        "AQID",
        ksp_raw_transaction_lib::RawTransactionWireField::Null,
        ksp_raw_transaction_lib::RawTransactionWireField::Value(ksp_raw_transaction_lib::RawTransactionVersion::Legacy),
        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
    );
    let transaction = ksp_raw_transaction_lib::canonicalize_raw_transaction(material);
    assert!(transaction.is_ok());
    return;
}

#[test]
fn pre_002_acquisition_assembly_accepts_store_api_producer_owned_metadata() {
    let network = match ksp_store_api::RawNetworkId::new("devnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let signature = match ksp_raw_transaction_lib::parse_raw_transaction_signature("1".repeat(64).as_str()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
        network,
        signature,
        5,
        std::option::Option::None,
        "AQID",
        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
        ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
    );
    let transaction = match ksp_raw_transaction_lib::canonicalize_raw_transaction(material) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provider = match ksp_store_api::RawProvenanceCode::new("fixture") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let protocol = match ksp_store_api::RawProvenanceCode::new("fixture.protocol") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let method = match ksp_store_api::RawProvenanceCode::new("fixture.method") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Import, received_at);
    let acquisition = ksp_raw_transaction_lib::assemble_raw_transaction_acquisition(transaction, ksp_store_api::RawObservationKey::new([9_u8; 32]), provenance);
    assert_eq!(acquisition.transaction().reference(), acquisition.observation().transaction());
    return;
}

#[test]
fn pre_004_embedded_signature_and_block_material_contract_are_available_from_crate_root() {
    let encoded = "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    let signature = ksp_raw_transaction_lib::extract_raw_transaction_signature_from_binary_base64(encoded);
    assert!(signature.is_ok());
    let network = ksp_store_api::RawNetworkId::new("devnet");
    assert!(network.is_ok());
    if let std::result::Result::Ok(network) = network {
        let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64_with_embedded_signature(
            network,
            1,
            std::option::Option::None,
            encoded,
            ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
            ksp_raw_transaction_lib::RawTransactionWireField::Omitted,
            ksp_raw_transaction_lib::RawTransactionWireField::Value(0),
        );
        assert!(material.is_ok());
    }
    return;
}

#[test]
fn pre_006_source_neutral_wire_contract_is_available_from_crate_root() {
    let message = ksp_raw_transaction_lib::RawSolanaTransactionMessage::new(
        ksp_raw_transaction_lib::RawSolanaMessageVersion::V1,
        ksp_raw_transaction_lib::RawSolanaMessageHeader::new(1, 0, 0),
        vec![[1_u8; 32]],
        [2_u8; 32],
        vec![ksp_raw_transaction_lib::RawSolanaCompiledInstruction::new(0, vec![0], vec![3])],
        vec![],
        std::option::Option::Some(ksp_raw_transaction_lib::RawSolanaTransactionConfig::default()),
    );
    let wire = ksp_raw_transaction_lib::RawSolanaTransactionWire::new(vec![[4_u8; 64]], message);
    let encoded = ksp_raw_transaction_lib::serialize_solana_transaction_wire_base64(&wire);
    assert!(encoded.is_ok());
    if let std::result::Result::Ok(encoded) = encoded {
        assert!(encoded.starts_with("gQ"));
        assert!(ksp_raw_transaction_lib::extract_raw_transaction_signature_from_binary_base64(encoded.as_str()).is_ok());
    }
    return;
}

#[test]
fn pre_004_signature_formatter_is_consumable_from_crate_root() {
    let signature = ksp_store_api::RawTransactionSignature::new([0_u8; 64]);
    let text = ksp_raw_transaction_lib::format_raw_transaction_signature(&signature);
    assert_eq!(text, "1".repeat(64));
    let parsed = ksp_raw_transaction_lib::parse_raw_transaction_signature(text.as_str());
    assert!(parsed.is_ok());
    if let std::result::Result::Ok(parsed) = parsed {
        assert_eq!(parsed, signature);
    }
    return;
}