Struct NetworkNotePricer 

pub struct NetworkNotePricer { /* private fields */ }

Re-export the entire miden_client crate so external projects can use a single dependency. Prices the consumption of notes by network accounts from their benchmarked cycle costs, e.g. to populate a network account’s fee schedule or to size a sponsorship.

The fee formula lives in TransactionFee; this pricer adds a safety margin expressed in extra verification cycles on top. The default margin prices a note as-if it consumed at twice its measured cycles.

The chain’s current FeeParameters provide the verification base fee. Costs are resolved from the standard and agglayer cost tables (StandardNote::note_cost and AgglayerNote::note_cost), so both families of notes are priced alike. Costs supplied through the builder’s note_costs take precedence over the tables, letting an account price note families the tables do not know — or a table-known script root whose consumption on that account runs extra code and so measures a different cost.

FeeSponsorshipNote defaults to zero because standard network-account fee collection exempts sponsorship notes from sponsoring themselves. A cost supplied through the builder’s note_cost or note_costs methods takes precedence over this default.

The computed fees are denominated in the given fee asset. A fee schedule stores bare amounts, so install the fees only into a policy whose FeePolicyManager charges in that same asset; Self::fee_asset_id exposes it for that check.

Implementations

impl NetworkNotePricer

pub fn builder() -> NetworkNotePricerBuilder

Create an instance of NetworkNotePricer using the builder syntax

impl NetworkNotePricer

pub fn fee_parameters(&self) -> &FeeParameters

Returns the chain fee parameters the pricer computes fees under.

pub fn fee_asset_id(&self) -> AssetId

Returns the asset the computed fees are denominated in.

pub fn fee( &self, fee_inputs: TransactionFee, ) -> Result<AssetAmount, NotePricingError>

Returns the fee charged for a network transaction with the given fee inputs, including the configured safety margin.

The fee is computed entirely by TransactionFee::compute_fee under the pricer’s FeeParameters, with the safety margin folded into the fee inputs (TransactionFee::with_safety_margin), so fee terms added to the kernel formula in the future flow through without changes here.

pub fn price( &self, root: NoteScriptRoot, ) -> Result<AssetAmount, NotePricingError>

Prices the consumption by a network account of the note with the given script root.

The price of a note is the fee for its own consumption plus the prices of the notes its consumption creates:

price(N) = fee(cycles(N)) + sum(price(M) for M created by consuming N)

Since a script root alone cannot tell whether a created note will be network-targeted, EVERY created note is priced in, suiting root-keyed fee schedules - though like the underlying costs, the result is an estimate, not a guaranteed upper bound (see the miden_standards::note::costs module docs). To avoid infinite recursion, a root already being priced further up the recursion contributes only its own consumption fee: a partially filled PSWAP is priced for one fill level, and the paybacks of any further partial fills are not covered.

pub fn basic_constant_fee_policy( &self, note_script_roots: impl IntoIterator<Item = NoteScriptRoot>, ) -> Result<BasicConstantFeePolicy, NotePricingError>

Builds a BasicConstantFeePolicy that prices every supplied note script root through Self::price.

The policy’s bare fee amounts are denominated in the fee asset configured by Self::fee_asset_id. Each root is priced through Self::price, so the fee includes the default safety margin and the recursively priced notes created by consuming it.

pub fn basic_constant_fee_policy_manager( &self, note_script_roots: impl IntoIterator<Item = NoteScriptRoot>, ) -> Result<FeePolicyManager, NotePricingError>

Builds a fee policy manager whose active BasicConstantFeePolicy is generated from the supplied note script roots.

The manager charges in the fee asset configured by Self::fee_asset_id, keeping the policy’s bare fee amounts and their denomination together.

Trait Implementations

impl Clone for NetworkNotePricer

fn clone(&self) -> NetworkNotePricer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NetworkNotePricer

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

Formats the value using the given formatter.