Struct WebLedger 

pub struct WebLedger {
    pub context: String,
    pub ledger_type: String,
    pub name: String,
    pub description: String,
    pub default_currency: String,
    pub created: u64,
    pub updated: u64,
    /* private fields */
}

The full Web Ledger document at /.well-known/webledgers/webledgers.json.

Balances change only through receipt-keyed operations: credit_by_outpoint (the outpoint is the receipt) and debit_by_payout (the payout id is the receipt), as in solidpayorg/teller. reverse_payout, charge and refund serve the pod’s broadcast recovery and access fees; none of them can raise a balance beyond what a recorded deposit put there.

A ledger built with with_genesis carries teller’s identity, id = urn:webledgers:<sha256(JCS(genesis))>; documents written before the genesis existed still load, without one.

The receipt-less mutators are crate-private. Outside this crate none of these compile:

let mut ledger = solid_pod_rs::payments::WebLedger::new("Pod Credits");
ledger.credit("did:nostr:aaaa", 1_000);

let mut ledger = solid_pod_rs::payments::WebLedger::new("Pod Credits");
let _ = ledger.debit("did:nostr:aaaa", 1);

let mut ledger = solid_pod_rs::payments::WebLedger::new("Pod Credits");
ledger.credit_currency("did:nostr:aaaa", "PODS", 1_000);

let mut ledger = solid_pod_rs::payments::WebLedger::new("Pod Credits");
ledger.entries.clear();

Fields

context: String

ledger_type: String

name: String

description: String

default_currency: String

created: u64

updated: u64

Implementations

impl WebLedger

pub fn new(name: &str) -> Self

A new, empty ledger without a genesis (the pre-teller shape).

pub fn with_genesis(genesis: LedgerGenesis) -> Result<Self, PaymentError>

A new, empty ledger born with genesis (teller newLedger): its hash is sha256(JCS(genesis)), its id urn:webledgers:<hash>, its name and defaultCurrency those of the genesis.

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

The ledger’s id, when it has one.

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

The ledger hash recorded in the document, when it has a genesis.

pub fn genesis(&self) -> Option<&LedgerGenesis>

The genesis the ledger was born with, if any.

pub fn ledger_hash(&self) -> Option<String>

The ledger hash recomputed from the genesis (teller ledgerHash).

pub fn check_genesis(&self) -> Result<(), PaymentError>

Teller checkLedger: a document with a genesis must record the hash of that genesis. Documents without a genesis (written before it existed) pass; a genesis without a matching hash does not.

pub fn entries(&self) -> &[LedgerEntry]

The balance entries, one per account.

pub fn deposits(&self) -> &[DepositReceipt]

Every deposit credited, by outpoint.

pub fn payouts(&self) -> &[PayoutReceipt]

Every payout debited, by payout id.

pub fn has_deposit(&self, txid: &str, vout: u32) -> bool

Whether outpoint (<txid>:<vout>) has already credited an account.

pub fn is_sats_unit(&self, currency: &str) -> bool

Whether currency names this ledger’s satoshi balance: satoshi, sat, or the ledger’s own defaultCurrency.

pub fn get_balance(&self, did: &str) -> u64

The satoshi balance of did (exact key match).

pub fn credit_by_outpoint( &mut self, account: &str, currency: &str, txid: &str, vout: u32, value: u64, ) -> Result<ReceiptOutcome, PaymentError>

Credit a deposit seen on-chain, once: the outpoint is the receipt (solidpayorg/teller credit, lib/teller.mjs:40-44).

currency is the unit credited: the ledger’s satoshi balance when is_sats_unit holds, otherwise that unit’s own balance (an MRC20 deposit credits its ticker, never sats). account is normalised as teller reads it (did:nostr:<x>, a bare x, or a Multikey’s x). The txid must be 64 lowercase hex digits and value a whole number no greater than 21 million coins in satoshis.

A second credit for an outpoint already recorded changes nothing and returns ReceiptOutcome::AlreadyApplied, whatever its account or unit.

use solid_pod_rs::payments::{ReceiptOutcome, WebLedger};

let alice = format!("did:nostr:{}", "a".repeat(64));
let txid = "ab".repeat(32);
let mut ledger = WebLedger::new("Pod Credits");
assert_eq!(
    ledger.credit_by_outpoint(&alice, "satoshi", &txid, 0, 50_000).unwrap(),
    ReceiptOutcome::Applied
);
assert_eq!(
    ledger.credit_by_outpoint(&alice, "satoshi", &txid, 0, 50_000).unwrap(),
    ReceiptOutcome::AlreadyApplied
);
assert_eq!(ledger.get_balance(&alice), 50_000);

pub fn debit_by_payout( &mut self, account: &str, amount: u64, txid: &str, ) -> Result<ReceiptOutcome, PaymentError>

Debit a withdrawal of amount satoshis, once: the payout’s txid is the receipt (solidpayorg/teller debit, lib/teller.mjs:53-58).

Fails with PaymentError::InsufficientBalance when the account holds less than amount. A second debit with a payout id already applied changes nothing and returns ReceiptOutcome::AlreadyApplied. Unlike teller, no 546-sat minimum applies here: the pod’s payouts include token transfers whose satoshi cost is not itself an on-chain output.

pub fn reverse_payout(&mut self, txid: &str) -> Option<u64>

Undo a recorded payout whose transaction never reached the chain: its amount goes back to its account and its receipt is removed. Returns the amount restored, or None when no payout with that id is recorded (nothing changes).

pub fn charge(&mut self, did: &str, amount: u64) -> Result<Charge, PaymentError>

Spend amount satoshis from did for an access fee (a paid request or an anchor). Fails closed with PaymentError::InsufficientBalance; the returned Charge is the only way to refund it.

pub fn refund(&mut self, charge: Charge)

Give back a Charge whose service was not delivered.

impl WebLedger

Extension methods on WebLedger for currency-specific operations.

The base WebLedger balance (get_balance) is the default satoshi balance. Trading requires per-currency balances, so these helpers work through the LedgerAmount::Multi representation. The credit and debit helpers are crate-private: outside this crate a balance is raised only by WebLedger::credit_by_outpoint, which records the deposit’s outpoint as its receipt.

pub fn get_currency_balance(&self, did: &str, currency: &str) -> u64

Get a DID’s balance in a specific currency.

Trait Implementations

impl Clone for WebLedger

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WebLedger

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WebLedger

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for WebLedger

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

where __S: Serializer,

Serialize this value into the given Serde serializer.