Struct Budget

pub struct Budget(/* private fields */);

Implementations

impl Budget

pub fn reset_models(&self) -> Result<(), HostError>

pub fn get_wasm_mem_alloc(&self) -> Result<u64, HostError>

pub fn reset_unlimited(&self) -> Result<(), HostError>

pub fn reset_unlimited_cpu(&self) -> Result<(), HostError>

pub fn reset_unlimited_mem(&self) -> Result<(), HostError>

pub fn cpu_limit_exceeded(&self) -> Result<bool, HostError>

pub fn mem_limit_exceeded(&self) -> Result<bool, HostError>

pub fn reset_tracker(&self) -> Result<(), HostError>

pub fn reset(&self) -> Result<(), HostError>

pub fn reset_cpu_limit(&self, cpu: u64) -> Result<(), HostError>

pub fn reset_limits(&self, cpu: u64, mem: u64) -> Result<(), HostError>

pub fn reset_fuel_config(&self) -> Result<(), HostError>

Resets the FuelConfig we pass into Wasmi before running calibration. Wasmi instruction calibration requires running the same Wasmi insn a fixed number of times, record their actual cpu and mem consumption, then divide those numbers by the number of iterations, which is the fuel count. Fuel count is kept tracked on the Wasmi side, based on the FuelConfig of a specific fuel category. In order to get the correct, unscaled fuel count, we have to preset all the FuelConfig entries to 1.

pub fn get_shadow_cpu_insns_consumed(&self) -> Result<u64, HostError>

pub fn get_shadow_mem_bytes_consumed(&self) -> Result<u64, HostError>

pub fn shadow_cpu_limit_exceeded(&self) -> Result<bool, HostError>

pub fn shadow_mem_limit_exceeded(&self) -> Result<bool, HostError>

impl Budget

pub fn try_from_configs( cpu_limit: u64, mem_limit: u64, cpu_cost_params: ContractCostParams, mem_cost_params: ContractCostParams, ) -> Result<Self, HostError>

Initializes the budget from network configuration settings.

pub fn bulk_charge( &self, ty: ContractCostType, iterations: u64, input: Option<u64>, ) -> Result<(), HostError>

Performs a bulk charge to the budget under the specified [CostType]. The iterations is the batch size. The caller needs to ensure:

1. the batched charges have identical costs (having the same [CostType] and input)
2. The input passed in (Some/None) is consistent with the [CostModel] underneath the [CostType] (linear/constant).

pub fn charge( &self, ty: ContractCostType, input: Option<u64>, ) -> Result<(), HostError>

Charges the budget under the specified [CostType]. The actual amount charged is determined by the underlying [CostModel] and may depend on the input. If the input is None, the model is assumed to be constant. Otherwise it is a linear model. The caller needs to ensure the input passed is consistent with the inherent model underneath.

pub fn get_tracker( &self, ty: ContractCostType, ) -> Result<CostTracker, HostError>

pub fn get_time(&self, ty: ContractCostType) -> Result<u64, HostError>

pub fn track_time( &self, ty: ContractCostType, duration: u64, ) -> Result<(), HostError>

pub fn get_cpu_insns_consumed(&self) -> Result<u64, HostError>

pub fn get_mem_bytes_consumed(&self) -> Result<u64, HostError>

pub fn get_cpu_insns_remaining(&self) -> Result<u64, HostError>

pub fn get_mem_bytes_remaining(&self) -> Result<u64, HostError>

pub fn reset_default(&self) -> Result<(), HostError>

Trait Implementations

impl AsBudget for &Budget

fn as_budget(&self) -> &Budget

impl AsBudget for Budget

fn as_budget(&self) -> &Budget

impl Clone for Budget

fn clone(&self) -> Budget

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compare<&[u8]> for Budget

type Error = HostError

fn compare(&self, a: &&[u8], b: &&[u8]) -> Result<Ordering, Self::Error>

impl<const N: usize> Compare<[u8; N]> for Budget

type Error = HostError

fn compare(&self, a: &[u8; N], b: &[u8; N]) -> Result<Ordering, Self::Error>

impl Compare<AccountId> for Budget

type Error = HostError

fn compare(&self, a: &AccountId, b: &AccountId) -> Result<Ordering, Self::Error>

impl Compare<ContractDataDurability> for Budget

type Error = HostError

fn compare( &self, a: &ContractDataDurability, b: &ContractDataDurability, ) -> Result<Ordering, Self::Error>

impl Compare<ContractExecutable> for Budget

type Error = HostError

fn compare( &self, a: &ContractExecutable, b: &ContractExecutable, ) -> Result<Ordering, Self::Error>

impl Compare<CreateContractArgs> for Budget

type Error = HostError

fn compare( &self, a: &CreateContractArgs, b: &CreateContractArgs, ) -> Result<Ordering, Self::Error>

impl Compare<CreateContractArgsV2> for Budget

type Error = HostError

fn compare( &self, a: &CreateContractArgsV2, b: &CreateContractArgsV2, ) -> Result<Ordering, Self::Error>

impl Compare<Duration> for Budget

type Error = HostError

fn compare(&self, a: &Duration, b: &Duration) -> Result<Ordering, Self::Error>

impl Compare<Hash> for Budget

type Error = HostError

fn compare(&self, a: &Hash, b: &Hash) -> Result<Ordering, Self::Error>

impl Compare<I256> for Budget

type Error = HostError

fn compare(&self, a: &I256, b: &I256) -> Result<Ordering, Self::Error>

impl Compare<Int128Parts> for Budget

type Error = HostError

fn compare( &self, a: &Int128Parts, b: &Int128Parts, ) -> Result<Ordering, Self::Error>

impl Compare<Int256Parts> for Budget

type Error = HostError

fn compare( &self, a: &Int256Parts, b: &Int256Parts, ) -> Result<Ordering, Self::Error>

impl Compare<LedgerKey> for Budget

type Error = HostError

fn compare(&self, a: &LedgerKey, b: &LedgerKey) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyAccount> for Budget

type Error = HostError

fn compare( &self, a: &LedgerKeyAccount, b: &LedgerKeyAccount, ) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyContractCode> for Budget

type Error = HostError

fn compare( &self, a: &LedgerKeyContractCode, b: &LedgerKeyContractCode, ) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyContractData> for Budget

type Error = HostError

fn compare( &self, a: &LedgerKeyContractData, b: &LedgerKeyContractData, ) -> Result<Ordering, Self::Error>

impl Compare<LedgerKeyTrustLine> for Budget

type Error = HostError

fn compare( &self, a: &LedgerKeyTrustLine, b: &LedgerKeyTrustLine, ) -> Result<Ordering, Self::Error>

impl<K, V> Compare<MeteredOrdMap<K, V, Budget>> for Budget

where K: DeclaredSizeForMetering, V: DeclaredSizeForMetering, Budget: Compare<K, Error = HostError> + Compare<V, Error = HostError>,

type Error = HostError

fn compare( &self, a: &MeteredOrdMap<K, V, Budget>, b: &MeteredOrdMap<K, V, Budget>, ) -> Result<Ordering, Self::Error>

impl<Elt: MeteredClone> Compare<MeteredVector<Elt>> for Budget

where Budget: Compare<Elt, Error = HostError>,

type Error = HostError

fn compare( &self, a: &MeteredVector<Elt>, b: &MeteredVector<Elt>, ) -> Result<Ordering, Self::Error>

impl Compare<PublicKey> for Budget

type Error = HostError

fn compare(&self, a: &PublicKey, b: &PublicKey) -> Result<Ordering, Self::Error>

impl Compare<ScAddress> for Budget

type Error = HostError

fn compare(&self, a: &ScAddress, b: &ScAddress) -> Result<Ordering, Self::Error>

impl Compare<ScContractInstance> for Budget

type Error = HostError

fn compare( &self, a: &ScContractInstance, b: &ScContractInstance, ) -> Result<Ordering, Self::Error>

impl Compare<ScError> for Budget

type Error = HostError

fn compare(&self, a: &ScError, b: &ScError) -> Result<Ordering, Self::Error>

impl Compare<ScMap> for Budget

type Error = HostError

fn compare(&self, a: &ScMap, b: &ScMap) -> Result<Ordering, Self::Error>

impl Compare<ScMapEntry> for Budget

type Error = HostError

fn compare( &self, a: &ScMapEntry, b: &ScMapEntry, ) -> Result<Ordering, Self::Error>

impl Compare<ScNonceKey> for Budget

type Error = HostError

fn compare( &self, a: &ScNonceKey, b: &ScNonceKey, ) -> Result<Ordering, Self::Error>

impl Compare<ScVal> for Budget

type Error = HostError

fn compare(&self, a: &ScVal, b: &ScVal) -> Result<Ordering, Self::Error>

impl Compare<ScVec> for Budget

type Error = HostError

fn compare(&self, a: &ScVec, b: &ScVec) -> Result<Ordering, Self::Error>

impl Compare<SymbolStr> for Budget

type Error = HostError

fn compare(&self, a: &SymbolStr, b: &SymbolStr) -> Result<Ordering, Self::Error>

impl Compare<TimePoint> for Budget

type Error = HostError

fn compare(&self, a: &TimePoint, b: &TimePoint) -> Result<Ordering, Self::Error>

impl Compare<TrustLineAsset> for Budget

type Error = HostError

fn compare( &self, a: &TrustLineAsset, b: &TrustLineAsset, ) -> Result<Ordering, Self::Error>

impl Compare<U256> for Budget

type Error = HostError

fn compare(&self, a: &U256, b: &U256) -> Result<Ordering, Self::Error>

impl Compare<UInt128Parts> for Budget

type Error = HostError

fn compare( &self, a: &UInt128Parts, b: &UInt128Parts, ) -> Result<Ordering, Self::Error>

impl Compare<UInt256Parts> for Budget

type Error = HostError

fn compare( &self, a: &UInt256Parts, b: &UInt256Parts, ) -> Result<Ordering, Self::Error>

impl Compare<Uint256> for Budget

type Error = HostError

fn compare(&self, a: &Uint256, b: &Uint256) -> Result<Ordering, Self::Error>

impl Compare<bool> for Budget

type Error = HostError

fn compare(&self, a: &bool, b: &bool) -> Result<Ordering, Self::Error>

impl Compare<i128> for Budget

type Error = HostError

fn compare(&self, a: &i128, b: &i128) -> Result<Ordering, Self::Error>

impl Compare<i32> for Budget

type Error = HostError

fn compare(&self, a: &i32, b: &i32) -> Result<Ordering, Self::Error>

impl Compare<i64> for Budget

type Error = HostError

fn compare(&self, a: &i64, b: &i64) -> Result<Ordering, Self::Error>

impl Compare<u128> for Budget

type Error = HostError

fn compare(&self, a: &u128, b: &u128) -> Result<Ordering, Self::Error>

impl Compare<u32> for Budget

type Error = HostError

fn compare(&self, a: &u32, b: &u32) -> Result<Ordering, Self::Error>

impl Compare<u64> for Budget

type Error = HostError

fn compare(&self, a: &u64, b: &u64) -> Result<Ordering, Self::Error>

impl Debug for Budget

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

Formats the value using the given formatter.

impl Default for Budget

fn default() -> Self

Returns the “default value” for a type.

impl Display for Budget

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

Formats the value using the given formatter.