reallyme-codec 0.4.0

ReallyMe codec utilities for strict DER, PEM, lowercase hex, multibase, multicodec, multikey, CBOR, JCS, and base encodings.
Documentation
// SPDX-FileCopyrightText: 2026 ReallyMe Technologies Limited
//
// SPDX-License-Identifier: MIT OR Apache-2.0

fn encode_test_protobuf<M: buffa::Message>(message: &M) -> Zeroizing<Vec<u8>> {
    encode_protobuf(message).unwrap()
}

#[test]
fn fixed_internal_error_response_matches_generated_wire_format() {
    let response = operation_response_from_result(Err(internal_wire_error()));
    let encoded = encode_test_protobuf(&response);
    assert_eq!(encoded.as_slice(), INTERNAL_ERROR_OPERATION_RESPONSE);
}

fn result_payload(response_bytes: &[u8]) -> TestOperationPayload {
    let response = decode_protobuf::<CodecOperationResponse>(response_bytes).unwrap();
    let outcome = response.outcome.as_ref();
    assert!(
        matches!(outcome, Some(codec_operation_response::Outcome::Result(_))),
        "expected generated operation result"
    );
    let Some(codec_operation_response::Outcome::Result(result)) = outcome else {
        return TestOperationPayload {
            bytes: Zeroizing::new(Vec::new()),
        };
    };
    let bytes = match result.result.as_ref().unwrap() {
        codec_operation_result::Result::MulticodecPrefixForName(value) => {
            encode_test_protobuf(value.as_ref())
        }
        codec_operation_result::Result::MulticodecLookupPrefix(value) => {
            encode_test_protobuf(value.as_ref())
        }
        codec_operation_result::Result::MulticodecTable(value) => {
            encode_test_protobuf(value.as_ref())
        }
        codec_operation_result::Result::MultikeyParse(value) => encode_test_protobuf(value.as_ref()),
        codec_operation_result::Result::DagCborVerifyCid(value) => {
            encode_test_protobuf(value.as_ref())
        }
        codec_operation_result::Result::DagCborEncode(value) => encode_test_protobuf(value.as_ref()),
        codec_operation_result::Result::DagCborDecode(value) => encode_test_protobuf(value.as_ref()),
        codec_operation_result::Result::PemDecode(value) => encode_test_protobuf(value.as_ref()),
        codec_operation_result::Result::PemEncode(value) => encode_test_protobuf(value.as_ref()),
        codec_operation_result::Result::DeterministicCborEncode(value) => {
            encode_test_protobuf(value.as_ref())
        }
        codec_operation_result::Result::DeterministicCborDecode(value) => {
            encode_test_protobuf(value.as_ref())
        }
    };
    TestOperationPayload { bytes }
}

fn codec_error_payload(response_bytes: &[u8]) -> CodecWireError {
    let response = decode_protobuf::<CodecOperationResponse>(response_bytes).unwrap();
    let outcome = response.outcome.as_ref();
    assert!(
        matches!(outcome, Some(codec_operation_response::Outcome::Error(_))),
        "expected generated operation error"
    );
    let Some(codec_operation_response::Outcome::Error(error)) = outcome else {
        return CodecWireError::malformed_protobuf();
    };
    let (branch, reason) = match error.error.as_ref().unwrap() {
        codec_error::Error::BaseEncoding(value) => {
            (CodecWireErrorBranch::BaseEncoding, value.reason)
        }
        codec_error::Error::Pem(value) => (CodecWireErrorBranch::Pem, value.reason),
        codec_error::Error::Multiformat(value) => {
            (CodecWireErrorBranch::Multiformat, value.reason)
        }
        codec_error::Error::Canonicalization(value) => {
            (CodecWireErrorBranch::Canonicalization, value.reason)
        }
        codec_error::Error::Backend(value) => (CodecWireErrorBranch::Backend, value.reason),
        codec_error::Error::Boundary(value) => (CodecWireErrorBranch::Boundary, value.reason),
    };
    let wire_error = CodecWireError::try_new(branch, reason.as_known().unwrap()).unwrap();
    let expected_origin = match wire_error.origin() {
        CodecWireErrorOrigin::Caller => CodecErrorOrigin::CODEC_ERROR_ORIGIN_CALLER,
        CodecWireErrorOrigin::Provider => CodecErrorOrigin::CODEC_ERROR_ORIGIN_PROVIDER,
        unexpected => {
            assert_eq!(unexpected, CodecWireErrorOrigin::Caller);
            CodecErrorOrigin::CODEC_ERROR_ORIGIN_CALLER
        }
    };
    assert_eq!(error.origin.as_known(), Some(expected_origin));
    wire_error
}

fn process_binary_and_proto_json(request: &CodecOperationRequest) -> Zeroizing<Vec<u8>> {
    let binary = process_operation_response(&request.encode_to_vec());
    let json = serde_json::to_vec(request).unwrap();
    let from_json = process_operation_response_json(&json);
    assert_eq!(binary.as_slice(), from_json.as_slice());
    binary
}

fn multikey_parse_request(multikey: &str) -> CodecOperationRequest {
    CodecOperationRequest {
        operation: Some(
            CodecMultikeyParseRequest {
                multikey: multikey.to_owned().into(),

            }
            .into(),
        ),

    }
}

fn dag_cbor_verify_cid_request(cid: &str, payload: &[u8]) -> CodecOperationRequest {
    CodecOperationRequest {
        operation: Some(
            CodecDagCborVerifyCidRequest {
                cid: cid.to_owned().into(),
                payload: payload.to_vec().into(),

            }
            .into(),
        ),

    }
}

fn pem_decode_request(
    pem: &[u8],
    options: Option<CodecPemDecodeOptions>,
) -> CodecOperationRequest {
    CodecOperationRequest {
        operation: Some(
            CodecPemDecodeRequest {
                pem: pem.to_vec().into(),
                options: match options {
                    Some(options) => buffa::MessageField::some(options),
                    None => buffa::MessageField::none(),
                },

            }
            .into(),
        ),

    }
}

fn deterministic_cbor_map_fixture() -> CodecDeterministicCborValue {
    CodecDeterministicCborValue {
        value: Some(
            CodecDeterministicCborMap {
                entries: vec![
                    CodecDeterministicCborMapEntry {
                        key: buffa::MessageField::some(CodecDeterministicCborMapKey {
                            key: Some(
                                CodecDeterministicCborText {
                                    value: "a".to_owned().into(),

                                }
                                .into(),
                            ),

                        }),
                        value: buffa::MessageField::some(CodecDeterministicCborValue {
                            value: Some(
                                CodecDeterministicCborInteger {
                                    value: Some(
                                        CodecDeterministicCborUnsignedInteger {
                                            value: 1,

                                        }
                                        .into(),
                                    ),

                                }
                                .into(),
                            ),

                        }),

                    },
                    CodecDeterministicCborMapEntry {
                        key: buffa::MessageField::some(CodecDeterministicCborMapKey {
                            key: Some(
                                CodecDeterministicCborInteger {
                                    value: Some(
                                        CodecDeterministicCborUnsignedInteger {
                                            value: 24,

                                        }
                                        .into(),
                                    ),

                                }
                                .into(),
                            ),

                        }),
                        value: buffa::MessageField::some(CodecDeterministicCborValue {
                            value: Some(
                                CodecDeterministicCborNull {

                                }
                                .into(),
                            ),

                        }),

                    },
                    CodecDeterministicCborMapEntry {
                        key: buffa::MessageField::some(CodecDeterministicCborMapKey {
                            key: Some(
                                CodecDeterministicCborInteger {
                                    value: Some(
                                        CodecDeterministicCborUnsignedInteger {
                                            value: 0,

                                        }
                                        .into(),
                                    ),

                                }
                                .into(),
                            ),

                        }),
                        value: buffa::MessageField::some(CodecDeterministicCborValue {
                            value: Some(
                                CodecDeterministicCborText {
                                    value: "zero".to_owned().into(),

                                }
                                .into(),
                            ),

                        }),

                    },
                ].into(),

            }
            .into(),
        ),

    }
}

fn dag_cbor_proto_fixture() -> CodecDeterministicCborValue {
    CodecDeterministicCborValue {
        value: Some(
            CodecDeterministicCborMap {
                entries: vec![
                    CodecDeterministicCborMapEntry {
                        key: buffa::MessageField::some(CodecDeterministicCborMapKey {
                            key: Some(
                                CodecDeterministicCborText {
                                    value: "z".to_owned().into(),

                                }
                                .into(),
                            ),

                        }),
                        value: buffa::MessageField::some(CodecDeterministicCborValue {
                            value: Some(
                                CodecDeterministicCborInteger {
                                    value: Some(
                                        CodecDeterministicCborNegativeInteger {
                                            value: -1,

                                        }
                                        .into(),
                                    ),

                                }
                                .into(),
                            ),

                        }),

                    },
                    CodecDeterministicCborMapEntry {
                        key: buffa::MessageField::some(CodecDeterministicCborMapKey {
                            key: Some(
                                CodecDeterministicCborText {
                                    value: "a".to_owned().into(),

                                }
                                .into(),
                            ),

                        }),
                        value: buffa::MessageField::some(CodecDeterministicCborValue {
                            value: Some(
                                CodecDeterministicCborBytes {
                                    value: vec![1, 2, 3].into(),

                                }
                                .into(),
                            ),

                        }),

                    },
                ].into(),

            }
            .into(),
        ),

    }
}

fn deterministic_cbor_nested_map_fixture(depth: usize) -> CodecDeterministicCborValue {
    let mut value = CodecDeterministicCborValue {
        value: Some(
            CodecDeterministicCborNull {

            }
            .into(),
        ),

    };
    for _ in 0..depth {
        value = CodecDeterministicCborValue {
            value: Some(
                CodecDeterministicCborMap {
                    entries: vec![CodecDeterministicCborMapEntry {
                        key: buffa::MessageField::some(CodecDeterministicCborMapKey {
                            key: Some(
                                CodecDeterministicCborInteger {
                                    value: Some(
                                        CodecDeterministicCborUnsignedInteger {
                                            value: 1,

                                        }
                                        .into(),
                                    ),

                                }
                                .into(),
                            ),

                        }),
                        value: buffa::MessageField::some(value),

                    }].into(),

                }
                .into(),
            ),

        };
    }
    value
}

// Unknown storage is disabled in native cleanup messages. Inject the original
// offending wire bytes so admission is tested before anything can be discarded.
fn with_unknown_wire_field<M: buffa::Message>(message: &M) -> Vec<u8> {
    let mut bytes = message.encode_to_vec();
    bytes.extend([0x98, 0x06, 0x07]); // field 99, varint 7
    bytes
}

fn length_delimited_wire(field: u32, payload: &[u8]) -> Vec<u8> {
    let mut bytes = Vec::new();
    buffa::encoding::encode_varint(u64::from(field).checked_mul(8).unwrap() | 2, &mut bytes);
    buffa::encoding::encode_varint(u64::try_from(payload.len()).unwrap(), &mut bytes);
    bytes.extend_from_slice(payload);
    bytes
}