Struct SkyState 

pub struct SkyState {
    pub component_id: String,
    pub kind: SkyComponentKind,
    /* private fields */
}

State for Sky mint/redeem components (LitePSM, USDS PSM wrapper, DaiUsds converter).

All components swap 1:1 modulo decimal rescaling; the PSM legs additionally apply the governance-mutable tin (stable out) / tout (stable in) wad fees. Balances bound the swap limits: the PSM’s pre-minted stable inventory and pocket gem inventory, or the join escrows (vat.dai[join], the burnable amount per side) for the converter. The wrapper is additionally bounded by both join escrows, which its in-flight DAI <-> USDS conversion burns through.

Fields

component_id: String

kind: SkyComponentKind

Implementations

impl SkyState

pub fn new( component_id: String, kind: SkyComponentKind, stable: Token, gem: Token, tin: U256, tout: U256, stable_balance: U256, gem_balance: U256, escrows: Option<JoinEscrows>, ) -> Self

Trait Implementations

impl Clone for SkyState

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 SkyState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SkyState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SkyState

impl PartialEq for SkyState

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

Equality operator ==.

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

Inequality operator !=.

impl ProtocolSim for SkyState

fn spot_price( &self, base: &Token, quote: &Token, ) -> Result<f64, SimulationError>

Buy price of base in quote (trait convention): acquiring gem goes through buyGem and costs 1 + tout stable per unit; acquiring stable goes through sellGem, where receiving 1 stable costs 1 / (1 - tin) gem.

fn query_pool_swap( &self, params: &QueryPoolSwapParams, ) -> Result<PoolSwap, SimulationError>

Closed-form implementation: prices are size-independent up to the hard capacity bound, so the crate’s generic root-search (built for falling AMM price curves, where it brackets and converges on an interior amount) would return an arbitrary probe instead of the true optimum on a flat curve.

• TradeLimitPrice is all-or-nothing: the full get_limits capacity if the flat execution price clears the limit, a zero-amount swap otherwise.
• PoolTargetPrice is only satisfiable where the pool already is: a zero-amount swap for a target within tolerance of spot, an error otherwise.

min_amount_in/max_amount_in are ignored, matching the generic helper.

fn fee(&self) -> f64

Returns the fee of the protocol as ratio

fn get_amount_out( &self, amount_in: BigUint, token_in: &Token, token_out: &Token, ) -> Result<GetAmountOutResult, SimulationError>

Returns the amount out given an amount in and input/output tokens.

fn get_limits( &self, sell_token: Bytes, buy_token: Bytes, ) -> Result<(BigUint, BigUint), SimulationError>

Computes the maximum amount that can be traded between two tokens.

fn delta_transition( &mut self, delta: ProtocolStateDelta, _tokens: &HashMap<Bytes, Token>, balances: &Balances, ) -> Result<(), TransitionError>

Decodes and applies a protocol state delta to the state

fn clone_box(&self) -> Box<dyn ProtocolSim>

Clones the protocol state as a trait object. This allows the state to be cloned when it is being used as a Box<dyn ProtocolSim>.

fn as_any(&self) -> &dyn Any

Allows downcasting of the trait object to its underlying type.

fn as_any_mut(&mut self) -> &mut dyn Any

Allows downcasting of the trait object to its mutable underlying type.

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

Compares two protocol states for equality. This method must be implemented to define how two protocol states are considered equal (used for tests).

fn as_indicatively_priced( &self, ) -> Result<&(dyn IndicativelyPriced + 'static), SimulationError>

Cast as IndicativelyPriced. This is necessary for RFQ protocols

fn apply_block(&mut self, _block: &BlockContext) -> bool

Advances the state to the block a quote is expected to execute in.

impl Serialize for SkyState

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 SkyState

impl TryFromWithBlock<ComponentWithState, BlockHeader> for SkyState

async fn try_from_with_header( snapshot: ComponentWithState, _block: BlockHeader, _account_balances: &HashMap<Bytes, HashMap<Bytes, Bytes>>, all_tokens: &HashMap<Bytes, Token>, _decoder_context: &DecoderContext, ) -> Result<Self, Self::Error>

Decodes a ComponentWithState into a SkyState, dispatching on the component_type static attribute (psm, psm_wrapper or converter).

type Error = InvalidSnapshotError