Struct Entry 

pub struct Entry<const P: u8 = 2> { /* private fields */ }

An entry draft: what a caller submits to be recorded.

Builders are infallible: an invalid key, kind, account path, dimension or memo is kept as a BuildError (see build_errors) and reported when the draft is recorded. P is inferred from the amounts or fixed by the type (Entry alone means Entry<2>).

use doubleentry::{Entry, amount, currency::EUR, error::Field};
use time::macros::date;

let draft: Entry = Entry::new("invoice-2026-0001", date!(2026 - 03 - 15))
    .debit("Assets:Cash", amount!("1190.00"), EUR)
    .credit("Income:Sales", amount!("1190.00"), EUR)
    .memo("Rechnung 4711");
assert!(draft.fingerprint().is_ok());

let broken: Entry = Entry::new("", date!(2026 - 03 - 15)).debit("Assets::Cash", amount!("1.00"), EUR);
let fields: Vec<Field> = broken.build_errors().iter().map(|e| e.field).collect();
assert_eq!(fields, [Field::Key, Field::Posting(0)]);

A hold action is not a builder choice (holds have their own constructors):

use doubleentry::{Entry, record::HoldAction};
let _ = Entry::<2>::new("k", time::macros::date!(2026 - 01 - 01))
    .hold_action(HoldAction::Open { expires: None });

Implementations

impl<const P: u8> Entry<P>

pub const MAX_POSTINGS: usize = 1024

The most postings in one entry.

pub const MAX_DOCUMENTS: usize = 16

The most documents on one entry.

pub const MAX_RATES: usize = 16

The most rates on one entry.

pub const MAX_MEMO_BYTES: usize = 4096

The most bytes of memo text.

pub fn new<K>(key: K, booking_date: Date) -> Self

where K: TryInto<IdempotencyKey>, K::Error: Into<ValueError>,

A draft under an idempotency key, booked on a date.

pub fn value_date(self, date: Date) -> Self

With a value date (defaults to the booking date).

pub fn captured_at(self, at: CaptureTime) -> Self

With the time the caller captured the entry.

pub fn kind<L>(self, kind: L) -> Self

where L: TryInto<Label>, L::Error: Into<ValueError>,

With an entry kind ("invoice", "payment", …).

pub fn memo(self, text: impl Into<String>) -> Self

With a memo: 1–4 096 bytes, tabs and line breaks allowed, no other control character (an invalid memo is rejected as 108 InvalidMemo). Its salt is supplied when the entry is recorded. The memo is the only free-text field (see the module docs).

pub fn memo_salted(self, text: impl Into<String>, salt: MemoSalt) -> Self

With a memo and the salt of its commitment.

pub fn document(self, document: Document) -> Self

With a source document.

pub fn debit<A>(self, account: A, amount: Amount<P>, currency: Currency) -> Self

where A: TryInto<AccountRef>, A::Error: Into<ValueError>,

With a debit posting.

pub fn credit<A>( self, account: A, amount: Amount<P>, currency: Currency, ) -> Self

where A: TryInto<AccountRef>, A::Error: Into<ValueError>,

With a credit posting.

pub fn posting(self, posting: Posting<P>) -> Self

With a posting built by Posting. On a hold (open_hold) the posting is Pending, on every other draft Settled.

pub fn open_hold<K>(key: K, booking_date: Date) -> Self

where K: TryInto<IdempotencyKey>, K::Error: Into<ValueError>,

A hold: a reservation of one amount from one account to another, resolved later exactly once. Add exactly one debit and one credit of the same amount and currency; on this draft they are Pending postings (anything else is refused with code 140). Optionally it expires.

The hold’s id is the id of its entry (Recorded::id), which its resolution names. While it is open, its amount counts against the balance limits of both accounts.

use doubleentry::{Entry, Layer, amount, date, currency::EUR};

let hold: Entry = Entry::open_hold("auth-4711", date!("2026-11-20"))
    .expires(date!("2026-11-30"))
    .debit("Liabilities:Wallets:alice", amount!("100.00"), EUR)
    .credit("Liabilities:Card:clearing", amount!("100.00"), EUR);
assert!(hold.postings().iter().all(|p| p.get_layer() == Layer::Pending));

pub fn expires(self, on: Date) -> Self

The first day a hold may be expired (expire_hold) and the first day it can no longer be posted. It must lie after the hold’s booking date (code 141). Only a hold expires: on any other draft this changes nothing.

use doubleentry::{Entry, date, record::HoldAction};

let hold: Entry = Entry::open_hold("auth-4711", date!("2026-11-20")).expires(date!("2026-11-30"));
assert_eq!(hold.get_hold(), Some(&HoldAction::Open { expires: Some(date!("2026-11-30")) }));
let entry: Entry = Entry::new("sale-1", date!("2026-11-20")).expires(date!("2026-11-30"));
assert_eq!(entry.get_hold(), None);

pub fn post_hold<K>( key: K, booking_date: Date, hold: EntryId, amount: PostAmount<P>, ) -> Self

where K: TryInto<IdempotencyKey>, K::Error: Into<ValueError>,

Posts (captures) the hold hold: all of it, or part with the rest released in the same entry. The draft carries no postings — the rule core derives them from the hold: the two Pending legs released, then the posted amount settled between the hold’s two accounts. A post must be booked before the hold’s expiry date.

use doubleentry::{AccountKind, Entry, Journal, Layer, LedgerId, PostAmount, amount, date, currency::EUR};

let mut books = Journal::new(LedgerId::new("example.com/payments")?);
books.declare_currency(EUR, 2, date!("2026-01-01"))?;
books.open("Liabilities:Wallets:alice", AccountKind::Liability, date!("2026-01-01"))?;
books.open("Liabilities:Card:clearing", AccountKind::Liability, date!("2026-01-01"))?;
books.define_months(2026, 11..=11)?;
let hold = books.record(
    Entry::open_hold("auth-4711", date!("2026-11-20"))
        .debit("Liabilities:Wallets:alice", amount!("100.00"), EUR)
        .credit("Liabilities:Card:clearing", amount!("100.00"), EUR),
)?;
let capture = books.record(Entry::post_hold(
    "capture-4711",
    date!("2026-11-22"),
    hold.id,
    PostAmount::Partial(amount!("60.00")),
))?;
let postings = books.entry(capture.id).map(|entry| entry.parts().postings.clone()).unwrap_or_default();
let legs: Vec<_> = postings.iter().map(|p| (p.layer, p.side, p.amount)).collect();
use doubleentry::Side::{Credit, Debit};
assert_eq!(legs, [
    (Layer::Pending, Credit, amount!("100.00")), // the reservation released
    (Layer::Pending, Debit, amount!("100.00")),
    (Layer::Settled, Debit, amount!("60.00")),   // the capture settled
    (Layer::Settled, Credit, amount!("60.00")),
]);

pub fn void_hold<K>(key: K, booking_date: Date, hold: EntryId) -> Self

where K: TryInto<IdempotencyKey>, K::Error: Into<ValueError>,

Voids (releases) the hold hold on any day from its booking date on, even after its expiry date or after one of its accounts closed. The core derives the two Pending release postings.

use doubleentry::{Entry, EntryId, date, record::HoldAction};

let hold = EntryId::from_bytes([7; 16]);
let void: Entry = Entry::void_hold("void-4711", date!("2026-11-21"), hold);
assert_eq!(void.get_hold(), Some(&HoldAction::Void { hold }));
assert!(void.postings().is_empty());

pub fn expire_hold<K>(key: K, booking_date: Date, hold: EntryId) -> Self

where K: TryInto<IdempotencyKey>, K::Error: Into<ValueError>,

Expires the hold hold: releases it like a void, booked on or after its expiry date. Nothing expires by itself — a scheduler lists the due holds (holds_due) and records an expiry for each.

use doubleentry::{Entry, EntryId, date, record::HoldAction};

let hold = EntryId::from_bytes([7; 16]);
let expiry: Entry = Entry::expire_hold("expire-4711", date!("2026-11-30"), hold);
assert_eq!(expiry.get_hold(), Some(&HoldAction::Expire { hold }));

pub fn reverses(self, target: EntryId) -> Self

Marks the draft as the reversal of an earlier entry.

pub fn rate(self, rate: Rate) -> Self

With an exchange rate; rates are kept sorted by (base, quote) and a second rate for the same pair replaces the first.

pub fn key(&self) -> Option<&IdempotencyKey>

The idempotency key; None when it was invalid.

pub const fn booking_date(&self) -> Date

The booking date.

pub fn get_value_date(&self) -> Date

The value date (the booking date unless set).

pub const fn get_captured_at(&self) -> Option<CaptureTime>

The capture time.

pub const fn get_kind(&self) -> Option<&Label>

The entry kind.

pub fn memo_text(&self) -> Option<&str>

The memo text.

pub fn memo_salt(&self) -> Option<&MemoSalt>

The memo salt, when the caller supplied one.

pub fn documents(&self) -> &[Document]

The documents, in the order added.

pub fn postings(&self) -> &[Posting<P>]

The postings, in the order added.

pub const fn get_reverses(&self) -> Option<EntryId>

The entry this one reverses.

pub const fn get_hold(&self) -> Option<&HoldAction<P>>

The hold action.

pub fn rates(&self) -> &[Rate]

The rates, sorted by (base, quote).

pub fn build_errors(&self) -> &[BuildError]

The builder arguments that failed validation, in the order given.

pub fn encoded_len(&self) -> usize

The length of the entry leaf this draft becomes, without allocating, to check against MAX_LEAF_BYTES before submitting. Meaningful only without build errors. A hold resolution’s derived postings (two to four) are not counted.

pub fn fingerprint(&self) -> Result<Fingerprint, BuildError>

The draft’s Fingerprint: a tagged SHA-256 of the entry body as submitted — accounts as given (path or handle), the memo as text, no salt — so it depends on nothing but the draft.

Errors

The first BuildError, while any exists.

pub fn id(&self, ledger: &LedgerId) -> Option<EntryId>

The id the entry will have in ledger; None while the key is invalid.

Trait Implementations

impl<const P: u8> Clone for Entry<P>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const P: u8> Debug for Entry<P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, const P: u8> Deserialize<'de> for Entry<P>

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<const P: u8> Eq for Entry<P>

impl<const P: u8> Hash for Entry<P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const P: u8> PartialEq for Entry<P>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<const P: u8> Serialize for Entry<P>

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const P: u8> StructuralPartialEq for Entry<P>