Struct UnbondArgs 

pub struct UnbondArgs {
    pub to_mbps: Option<u64>,
    pub all: bool,
    pub amount: Option<u128>,
    pub yes: bool,
    pub chain: ChainArgs,
}

decdn node unbond — lower the bond via CapacityBond.requestUnbond + unbond (ADR 026 § Capacity-bond curve). One command covers all three phases of the window; which one runs is read from chain state, not from a flag. A run that lost its requestUnbond after declareMbps landed resumes on re-run, the way BondArgs converges; once requestUnbond HAS landed a re-run with an amount flag is a deliberate error, since the request can no longer be changed.

The amount flags apply only when starting a request — passing one while a request is already in flight is an error rather than a silent no-op. All three are mutually exclusive; exactly one is required to start a request.

Fields

to_mbps: Option<u64>

Reduce the declared capacity tier to MBPS and release the surplus bond. The released amount is derived from the on-chain bondRequired curve — you do not pass a token amount. The retained bond is max(minBond, bondRequired(MBPS)), so the node stays eligible at the new tier. Must not exceed the current declared tier (raise with decdn node bond --mbps); passing the tier the node is already at is accepted and skips the redundant declareMbps, which is how a partially-failed run resumes. A tier that will actually be declared must be inside the governable [minCapacityMbps, maxCapacityMbps] band.

all: bool

Release everything the bond curve permits, retaining only bondRequired(declaredMbps). Unlike --to-mbps this ignores the minBond floor, so at low declared tiers the retained bond can land below minBond and the node stays inactive until it re-bonds. Whether it does is tier-dependent; the command reports below_min_bond before submitting.

For an operator that is NOT in the registered set — ejected, or bonded and declared but never registered — this additionally clears the declared tier (declareMbps(0)), making it a full exit: nothing is retained. That is the only route to the bond those operators have, since decdn node deregister requires an active registration. A registered node exits by running decdn node deregister first.

amount: Option<u128>

Release exactly this many TOKEN base units (1 TOKEN = 1e18). Escape hatch for an exact figure; the curve is still pre-checked, so an amount the contract would reject fails with the decdn node bond --mbps invocation needed to make it legal.

yes: bool

Skip the interactive confirmation. Required when starting a request from a non-interactive shell, since that deactivates the node for the full window; the withdrawal phase never prompts. The consequences are printed either way — this suppresses the prompt, not the warning.

chain: ChainArgs

Chain coordinates: RPC endpoint, contract addresses, and keystore.

Trait Implementations

impl Args for UnbondArgs

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Debug for UnbondArgs

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

Formats the value using the given formatter.

impl FromArgMatches for UnbondArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.