icydb-core 0.200.0

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Module: index::key::ordered::segments
//! Responsibility: ordered byte-segment helpers for compound/scoped value kinds.
//! Does not own: numeric normalization policy.
//! Boundary: internal helper for ordered component encoding.

use crate::{
    db::index::key::ordered::OrderedValueEncodeError,
    types::{Account, Principal, Subaccount},
};

const LENGTH_BYTES: usize = 2;
const ACCOUNT_OWNER_MAX_LEN: usize = Principal::MAX_LENGTH_IN_BYTES as usize;
const ACCOUNT_SUBACCOUNT_LEN: usize = 32;
const ACCOUNT_SUBACCOUNT_TAG: u8 = 0x80;

/// Account ordering uses the same tuple contract as `Account::cmp`.
pub(super) fn push_account_payload(
    out: &mut Vec<u8>,
    account: &Account,
) -> Result<(), OrderedValueEncodeError> {
    let owner_principal = account.owner();
    let owner = owner_principal.as_slice();
    let owner_len = owner.len();
    if owner_len > ACCOUNT_OWNER_MAX_LEN {
        return Err(OrderedValueEncodeError::AccountOwnerTooLarge);
    }

    let mut ordering_tag =
        u8::try_from(owner_len).expect("account owner length should fit in one byte");
    if account.subaccount().is_some() {
        ordering_tag |= ACCOUNT_SUBACCOUNT_TAG;
    }

    out.push(ordering_tag);

    let mut owner_padded = [0u8; ACCOUNT_OWNER_MAX_LEN];
    owner_padded[..owner_len].copy_from_slice(&owner[..owner_len]);
    out.extend_from_slice(&owner_padded);

    let subaccount = account.subaccount().unwrap_or(Subaccount::MIN).to_array();
    let _ = ACCOUNT_SUBACCOUNT_LEN;
    out.extend_from_slice(&subaccount);

    Ok(())
}

/// Byte strings are escaped so tuple boundaries remain unambiguous.
/// Segment size bounds for these terminated payloads are enforced by the outer
/// index-key component caps in `IndexKey`, not at this primitive encoder layer.
pub(super) fn push_terminated_bytes(out: &mut Vec<u8>, bytes: &[u8]) {
    for &byte in bytes {
        if byte == 0 {
            out.extend_from_slice(&[0, 0xFF]);
        } else {
            out.push(byte);
        }
    }

    out.extend_from_slice(&[0, 0]);
}

pub(super) fn push_inverted(out: &mut Vec<u8>, bytes: &[u8]) {
    for &byte in bytes {
        out.push(!byte);
    }
}

pub(super) fn encode_segment_len(
    len: usize,
) -> Result<[u8; LENGTH_BYTES], OrderedValueEncodeError> {
    let len_u16 = u16::try_from(len).map_err(|_| OrderedValueEncodeError::SegmentTooLarge)?;

    Ok(len_u16.to_be_bytes())
}