Struct kaspa_wasm::MassCalculator

pub struct MassCalculator { /* private fields */ }

Implementations

impl MassCalculator

pub fn new(cp: ConsensusParams) -> MassCalculator

pub fn is_dust(&self, amount: u64) -> bool

pub fn is_transaction_output_dust( transaction_output: JsValue ) -> Result<bool, Error>

isTransactionOutputDust() returns whether or not the passed transaction output amount is considered dust or not based on the configured minimum transaction relay fee.

Dust is defined in terms of the minimum transaction relay fee. In particular, if the cost to the network to spend coins is more than 1/3 of the minimum transaction relay fee, it is considered dust.

It is exposed by MiningManager for use by transaction generators and wallets.

pub fn minimum_relay_transaction_fee() -> u32

minimumRelayTransactionFee() specifies the minimum transaction fee for a transaction to be accepted to the mempool and relayed. It is specified in sompi per 1kg (or 1000 grams) of transaction mass.

pub(crate) const MINIMUM_RELAY_TRANSACTION_FEE: u64 = 1000;

pub fn maximum_standard_transaction_mass() -> u32

maximumStandardTransactionMass() is the maximum mass allowed for transactions that are considered standard and will therefore be relayed and considered for mining.

pub const MAXIMUM_STANDARD_TRANSACTION_MASS: u64 = 100_000;

pub fn calc_minimum_required_transaction_relay_fee(mass: u32) -> u32

minimum_required_transaction_relay_fee returns the minimum transaction fee required for a transaction with the passed mass to be accepted into the mempool and relayed.

pub fn calc_mass_for_transaction(&self, tx: JsValue) -> Result<u32, Error>

pub fn blank_transaction_serialized_byte_size() -> u32

pub fn blank_transaction_mass(&self) -> u32

pub fn calc_mass_for_payload(&self, payload_byte_size: usize) -> u32

pub fn calc_mass_for_outputs(&self, outputs: JsValue) -> Result<u32, Error>

pub fn calc_mass_for_inputs(&self, inputs: JsValue) -> Result<u32, Error>

pub fn calc_mass_for_output( &self, output: &TransactionOutput ) -> Result<u32, Error>

pub fn calc_mass_for_input( &self, input: &TransactionInput ) -> Result<u32, Error>

pub fn calc_signature_mass(&self, minimum_signatures: u16) -> u32

pub fn calc_signature_mass_for_inputs( &self, number_of_inputs: usize, minimum_signatures: u16 ) -> u32

pub fn calc_minimum_transaction_relay_fee_from_mass(&self, mass: u64) -> u32

pub fn calc_minimum_transaction_relay_fee( &self, transaction: &Transaction, minimum_signatures: u16 ) -> Result<u32, Error>

Trait Implementations

impl From<MassCalculator> for JsValue

fn from(value: MassCalculator) -> JsValue

Converts to this type from the input type.

impl FromWasmAbi for MassCalculator

type Abi = u32

The wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> MassCalculator

Recover a Self from Self::Abi.

impl IntoWasmAbi for MassCalculator

type Abi = u32

The wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl LongRefFromWasmAbi for MassCalculator

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = Ref<'static, MassCalculator>

Same as RefFromWasmAbi::Anchor

unsafe fn long_ref_from_abi( js: <MassCalculator as LongRefFromWasmAbi>::Abi ) -> <MassCalculator as LongRefFromWasmAbi>::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl OptionFromWasmAbi for MassCalculator

fn is_none(abi: &<MassCalculator as FromWasmAbi>::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for MassCalculator

fn none() -> <MassCalculator as IntoWasmAbi>::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl RefFromWasmAbi for MassCalculator

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, MassCalculator>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi( js: <MassCalculator as RefFromWasmAbi>::Abi ) -> <MassCalculator as RefFromWasmAbi>::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for MassCalculator

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RefMut<'static, MassCalculator>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi( js: <MassCalculator as RefMutFromWasmAbi>::Abi ) -> <MassCalculator as RefMutFromWasmAbi>::Anchor

Same as RefFromWasmAbi::ref_from_abi