Enum MetaValueJson 

pub enum MetaValueJson {
    String(String),
    Bool(bool),
    Amount {
        number: String,
        currency: String,
    },
    Null,
}

Metadata-value wire format for WASM consumers.

JSON output is byte-equivalent to FFI-WASI’s meta_value_to_json — JS clients writing portable code see identical metadata values from both bindings. The Rust-side types are independent though: FFI-WASI emits serde_json::Value (untyped), this crate emits a typed enum. Unifying the source-of-truth is tracked by issue #1200 item 2.

The host’s rustledger_core::MetaValue is richer than the wire type — Account/Currency/Tag/Link/Date/Number all flatten to JSON strings here, matching FFI-WASI behavior. JS consumers that need the strong type info should query the host via a typed API; this enum is the lossy-but-portable view.

Untagged on the wire: "hello" serializes as a string, true as a boolean, null as null, and an AmountValue {number,currency} as a plain object. The TypeScript union is Record<string, string | boolean | {number, currency} | null> — no raw JSON number arm because MetaValue::Number (Decimal) stringifies to preserve precision. Issue #1168 proposed string | number | boolean | null; we substitute the {number,currency} shape for number so cost-bearing metadata round-trips cleanly and so JS numeric literals don’t silently alias into the wire (see the meta_value_json_rejects_raw_json_number test).

Variants

String(String)

String/Account/Currency/Tag/Link/Date/Number — anything the host can represent as a string, including rust_decimal::Decimal values stringified to preserve precision (JSON numbers can’t represent arbitrary-precision decimals losslessly).

Bool(bool)

Boolean values.

Amount

Amount values ({number, currency}) — the only structured shape that survives the round-trip. Same {number, currency} envelope as AmountValue so JS consumers can branch on shape without a discriminator tag.

Deserialize note: serde’s untagged-enum matcher accepts extra fields in a JSON object (#[serde(deny_unknown_fields)] can’t be applied per-variant on an untagged enum without breaking the wider match). A JS client sending {number: "100", currency: "USD", extra: "x"} deserializes as Amount { number: "100", currency: "USD" } with extra silently dropped. Output-side consumers (the production path) are unaffected; treat Deserialize here as best-effort and validate at the host boundary if you need stricter checks.

Fields

number: String

The decimal quantity, stringified for precision.

currency: String

The currency code.

Null

Absent / null metadata value. Deserializes from JSON null; serializes to JSON null. (Serde supports unit variants in untagged enums for null values specifically — a less common pattern than struct/tuple variants but well-defined.)

Trait Implementations

impl Clone for MetaValueJson

fn clone(&self) -> MetaValueJson

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaValueJson

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MetaValueJson

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MetaValueJson

impl PartialEq for MetaValueJson

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for MetaValueJson

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MetaValueJson