Struct MarketConfiguration

pub struct MarketConfiguration {

    pub time_chunk_configuration: TimeChunkConfiguration,
    pub borrow_asset: FungibleAsset<BorrowAsset>,
    pub collateral_asset: FungibleAsset<CollateralAsset>,
    pub price_oracle_configuration: PriceOracleConfiguration,
    pub borrow_mcr_maintenance: Decimal,
    pub borrow_mcr_liquidation: Decimal,
    pub borrow_asset_maximum_usage_ratio: Decimal,
    pub borrow_origination_fee: Fee<BorrowAsset>,
    pub borrow_interest_rate_strategy: InterestRateStrategy,
    pub borrow_maximum_duration_ms: Option<U64>,
    pub borrow_range: ValidAmountRange<BorrowAsset>,
    pub supply_range: ValidAmountRange<BorrowAsset>,
    pub supply_withdrawal_range: ValidAmountRange<BorrowAsset>,
    pub supply_withdrawal_fee: TimeBasedFee<BorrowAsset>,
    pub yield_weights: YieldWeights,
    pub protocol_account_id: AccountId,
    pub liquidation_maximum_spread: Decimal,
}

Configuration for a single asset-pair borrow market.

A market’s configuration is immutable after deployment.

Fields

time_chunk_configuration: TimeChunkConfiguration

As time passes, the market creates snapshots of its state. These snapshots are used to calculate the interest charged to borrowers, yield earned by suppliers, etc. A time chunk represents the period of time over which a snapshot is taken, and is used as a disambiguating index for snapshots.

borrow_asset: FungibleAsset<BorrowAsset>

The borrow asset supported by this market.

collateral_asset: FungibleAsset<CollateralAsset>

The collateral asset supported by this market.

price_oracle_configuration: PriceOracleConfiguration

The market communicates with a price oracle to determine asset valuations.

borrow_mcr_maintenance: Decimal

A borrow position must satisfy this minimum collateralization ratio after any modifications (e.g. withdrawing collateral).

Must be greater than or equal to borrow_mcr_liquidation.

borrow_mcr_liquidation: Decimal

A borrow position is eligible for liquidation if it does not satisfy this minimu collateralization ratio.

Must be less than or equal to borrow_mcr_maintenance.

borrow_asset_maximum_usage_ratio: Decimal

Maintain a reserve of some% of the deposited supply; how much of the deposited principal may be lent out (up to 100%)? This is a matter of protection for supply providers.

borrow_origination_fee: Fee<BorrowAsset>

The origination fee is a one-time amount added to the principal of the borrow. That is to say, the origination fee is denominated in units of the borrow asset and is paid by the borrowing account during repayment (or liquidation).

borrow_interest_rate_strategy: InterestRateStrategy

Interest rate is decided by a function of utilization ratio [0.0, 1.0].

borrow_maximum_duration_ms: Option<U64>

If a maximum borrow duration is configured, a borrow position is instantly eligible for liquidation (regardless of collateralization ratio) after this period has expired.

borrow_range: ValidAmountRange<BorrowAsset>

A borrow position’s principal must be within this range after modification.

supply_range: ValidAmountRange<BorrowAsset>

A supply position’s deposit must be within this range after modification.

supply_withdrawal_range: ValidAmountRange<BorrowAsset>

A supply position may only request to withdraw amounts within this range.

supply_withdrawal_fee: TimeBasedFee<BorrowAsset>

A time-bound fee for supply, to discourage extremely short-lived supply positions.

yield_weights: YieldWeights

Determines how yield is distributed between suppliers (dynamically allocated based on deposit) and statically-configured accounts (e.g. a protocol insurance account).

protocol_account_id: AccountId

For collecting supply withdrawal fees.

Supply withdrawal fees cannot be distributed to other suppliers because there may not be any suppliers to earn those fees after the last one withdraws.

liquidation_maximum_spread: Decimal

How far below market rate to accept liquidation? This is effectively the liquidator’s spread.

For example, if a 100USDC borrow is (under)collateralized with $110 of NEAR, a “maximum liquidator spread” of 1% would mean that a liquidator could liquidate this borrow by sending 108.9USDC, netting the liquidator $110 * 1% = $1.1 of NEAR.

Implementations

impl MarketConfiguration

pub fn validate(&self) -> Result<(), ConfigurationValidationError>

Errors

If the configuration is invalid.

pub fn borrow_status( &self, collateralization_ratio: Option<Decimal>, started_at_block_timestamp_ms: Option<impl Into<u64>>, block_timestamp_ms: u64, ) -> BorrowStatus

pub fn minimum_acceptable_liquidation_amount( &self, amount: CollateralAssetAmount, price_pair: &PricePair, ) -> Option<BorrowAssetAmount>

pub fn single_snapshot_maximum_interest(&self) -> Decimal

pub fn supply_yield_rate_from_interest(&self, snapshot: &Snapshot) -> Decimal

Trait Implementations

impl BorshDeserialize for MarketConfiguration

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for MarketConfiguration

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl Clone for MarketConfiguration

fn clone(&self) -> MarketConfiguration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MarketConfiguration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MarketConfiguration

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MarketConfiguration

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MarketConfiguration

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MarketConfiguration

impl StructuralPartialEq for MarketConfiguration