Enum BatchTransition 

pub enum BatchTransition {
    V0(BatchTransitionV0),
    V1(BatchTransitionV1),
}

Variants

V0(BatchTransitionV0)

V1(BatchTransitionV1)

Implementations

impl BatchTransition

pub fn requests_gas_sponsorship(&self) -> bool

Whether every transition of the batch asks the contract owner to pay its gas: each one is a document transition whose token payment info requests ContractOwner or PreferContractOwner. Only the data contracts can say whether that request is honoured, so this is what the minimum balance pre-check can know before they are loaded.

pub fn validate_estimated_principal( &self, identity_known_balance: Credits, ) -> Result<SimpleConsensusValidationResult, ProtocolError>

The minimum balance pre-check of a batch that asks the contract owner to pay its gas: the document owner still funds the principal (document purchases and the collateral of contested creates) from their own balance, but not the per-transition fee minimum, which fee validation then judges against whoever ends up paying.

pub fn validate_estimated_principal_with_shielded_compute( &self, identity_known_balance: Credits, platform_version: &PlatformVersion, ) -> Result<SimpleConsensusValidationResult, ProtocolError>

The principal a sponsored batch’s signer funds, plus the compute fee of the Orchard bundles it carries.

A sponsor pays the gas of a batch that executes, but a sub-transition its state validation replaces with a nonce bump takes the sponsor off the whole batch, and the signer pays for the work that ran on it. So the signer has to hold what the verification costs even while a sponsor is expected to pay it: whichever way the batch ends, somebody can be charged for the proofs already verified. A batch carrying no bundle adds nothing and is asked for its principal alone, as before.

pub fn shielded_bundle_compute_fee( &self, platform_version: &PlatformVersion, ) -> Result<Credits, ProtocolError>

The shielded compute fee the batch’s Orchard bundles will be charged: one bundle verification plus the per-action work, summed over the sub-transitions that carry a bundle, each priced exactly as the transformer that builds it prices it.

A bundle is carried either by a token transition against a shielded pool or by a document whose token cost is paid out of the payment token’s pool.

pub fn validate_estimated_fee_with_shielded_compute( &self, identity_known_balance: Credits, platform_version: &PlatformVersion, ) -> Result<SimpleConsensusValidationResult, ProtocolError>

The minimum balance pre-check of a batch, reserving the shielded compute fee of the bundles it carries on top of the flat per-sub-transition minimum.

The flat minimum is orders of magnitude below what one bundle costs, and reserving only that leaves the Halo 2 verification unfunded. A claim into a pool makes the gap exploitable: its claimable amount is only known against state, so its proof is skipped in check tx, and a signer holding only the flat minimum passes the mempool without any verification running. Every validator then runs it inside block validation, where the concurrency permit that guards admission does not apply, and the batch is refused unpaid — nothing charged, the identity contract nonce untouched — so the same bytes replay. Reserving the fee here refuses the batch before the proof work is done, and refuses nothing that could have been executed: every bundle-carrying sub-transition is charged this same fee as its action is built, before anything about it can fail, so a signer who cannot cover it is refused by fee validation in any case.

That last claim rests on a number, not on the structure. The floor asks for flat_minimum + compute_fee where fee validation asks for metered_fee + compute_fee, so the floor refuses somebody fee validation would not exactly when metered_fee < flat_minimum. A sub-transition carrying a bundle writes notes and nullifiers, whose metered storage alone prices it two orders of magnitude above the flat minimum, so no such batch exists. Anything that lets a bundle ride on a sub-transition cheaper than the flat minimum reopens that band; the same reasoning is recorded on SystemLimits::max_transitions_in_documents_batch, which is where the shape of a batch is decided.

The caller decides whether to ask for it. A batch that asks the contract owner to pay its gas is not asked, because the compute fee is gas.

impl BatchTransition

pub fn validate_base_structure( &self, platform_version: &PlatformVersion, ) -> Result<SimpleConsensusValidationResult, ProtocolError>

impl BatchTransition

pub fn feature_version(&self) -> FeatureVersion

pub fn verify_protocol_version( &self, protocol_version: u32, ) -> Result<bool, ProtocolError>

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for BatchTransition

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl<'__de, __Context> BorrowDecodeUntrusted<'__de, __Context> for BatchTransition

fn borrow_decode_untrusted<__D: BorrowUntrustedDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Borrow-decode with explicit untrusted field dispatch and resource handling.

impl Clone for BatchTransition

fn clone(&self) -> BatchTransition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BatchTransition

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for BatchTransition

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<__Context> DecodeUntrusted<__Context> for BatchTransition

fn decode_untrusted<__D: UntrustedDecoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Decode with explicit untrusted field dispatch and resource handling.

impl<'de> Deserialize<'de> for BatchTransition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DocumentsBatchTransitionAccessorsV0 for BatchTransition

fn transitions_iter(&self) -> Self::IterType<'_>

Iterator for BatchedTransitionRef items.

type IterType<'a> = DocumentBatchIterator<'a> where Self: 'a

Associated type for the iterator.

fn transitions_len(&self) -> usize

fn transitions_are_empty(&self) -> bool

fn first_transition(&self) -> Option<BatchedTransitionRef<'_>>

fn first_transition_mut(&mut self) -> Option<BatchedTransitionMutRef<'_>>

fn contains_document_transition(&self) -> bool

fn contains_token_transition(&self) -> bool

impl DocumentsBatchTransitionMethodsV0 for BatchTransition

fn all_document_purchases_amount( &self, ) -> Result<Option<Credits>, ProtocolError>

fn all_conflicting_index_collateral_voting_funds( &self, ) -> Result<Option<Credits>, ProtocolError>

fn set_transitions(&mut self, transitions: Vec<BatchedTransition>)

fn set_identity_contract_nonce( &mut self, identity_contract_nonce: IdentityNonce, )

async fn new_document_creation_transition_from_document<S: Signer<IdentityPublicKey>>( document: Document, document_type: DocumentTypeRef<'_>, entropy: [u8; 32], identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, token_payment_info: Option<TokenPaymentInfo>, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

async fn new_document_replacement_transition_from_document<S: Signer<IdentityPublicKey>>( document: Document, document_type: DocumentTypeRef<'_>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, token_payment_info: Option<TokenPaymentInfo>, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

async fn new_document_transfer_transition_from_document<S: Signer<IdentityPublicKey>>( document: Document, document_type: DocumentTypeRef<'_>, recipient_owner_id: Identifier, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, token_payment_info: Option<TokenPaymentInfo>, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

async fn new_document_deletion_transition_from_document<S: Signer<IdentityPublicKey>>( document: Document, document_type: DocumentTypeRef<'_>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, token_payment_info: Option<TokenPaymentInfo>, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

async fn new_document_update_price_transition_from_document<S: Signer<IdentityPublicKey>>( document: Document, document_type: DocumentTypeRef<'_>, price: Credits, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, token_payment_info: Option<TokenPaymentInfo>, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

async fn new_document_purchase_transition_from_document<S: Signer<IdentityPublicKey>>( document: Document, document_type: DocumentTypeRef<'_>, new_owner_id: Identifier, price: Credits, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, token_payment_info: Option<TokenPaymentInfo>, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

fn combined_security_level_requirement( &self, get_data_contract_security_level_requirement: Option<impl Fn(Identifier, String) -> Result<SecurityLevel, ProtocolError>>, ) -> Result<Vec<SecurityLevel>, ProtocolError>

impl DocumentsBatchTransitionMethodsV1 for BatchTransition

async fn new_token_mint_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: TokenContractPosition, amount: TokenAmount, issued_to_identity_id: Option<Identifier>, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to mint new tokens.

async fn new_token_burn_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to burn tokens, permanently removing them from circulation.

async fn new_token_transfer_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, recipient_id: Identifier, public_note: Option<String>, shared_encrypted_note: Option<SharedEncryptedNote>, private_encrypted_note: Option<PrivateEncryptedNote>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to transfer tokens from one identity to another.

async fn new_token_shield_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, bundle: OrchardBundleParams, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition moving amount of a token from owner_id’s identity token balance into the token’s shielded pool.

async fn new_token_mint_to_pool_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, bundle: OrchardBundleParams, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition minting amount of a token straight into the token’s shielded pool as the notes in bundle. owner_id must be authorized to mint; it signs and pays the credits fee. A group action is set up exactly like a transparent mint.

async fn new_token_burn_from_pool_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, bundle: OrchardBundleParams, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition destroying amount of a token held in the token’s shielded pool by spending the notes in bundle. owner_id must be authorized to burn; it signs and pays the credits fee.

async fn new_token_claim_to_pool_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, distribution_type: TokenDistributionType, claim_up_to: Option<u64>, bundle: OrchardBundleParams, public_note: Option<String>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition claiming a distribution straight into the token’s shielded pool as the notes in bundle. claim_up_to names the cycle-aligned moment a perpetual claim pays out to, so the bundle’s value can be predicted; owner_id signs and pays the credits fee.

async fn new_token_direct_purchase_to_pool_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, token_count: TokenAmount, total_agreed_price: Credits, bundle: OrchardBundleParams, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition buying token_count tokens for at most total_agreed_price credits and receiving them shielded as the notes in bundle. owner_id pays the price and the credits fee.

async fn new_token_unshield_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, recipient_id: Identifier, bundle: OrchardBundleParams, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition moving amount of a token out of the token’s shielded pool into recipient_id’s identity token balance. owner_id signs and pays the credits fee.

async fn new_token_shielded_transfer_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, bundle: OrchardBundleParams, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition transferring a token inside its shielded pool. owner_id signs and pays the credits fee.

async fn new_token_freeze_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, freeze_identity_id: Identifier, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to freeze tokens belonging to a specific identity.

async fn new_token_unfreeze_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, unfreeze_identity_id: Identifier, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to unfreeze tokens previously frozen for a specific identity.

async fn new_token_destroy_frozen_funds_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, frozen_identity_id: Identifier, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to destroy previously frozen tokens, removing them permanently from supply.

async fn new_token_emergency_action_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, emergency_action: TokenEmergencyAction, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to execute an emergency action for a token.

async fn new_token_config_update_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, update_token_configuration_item: TokenConfigurationChangeItem, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to update the configuration of a token.

async fn new_token_claim_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, distribution_type: TokenDistributionType, public_note: Option<String>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to claim tokens from a distribution source.

async fn new_token_change_direct_purchase_price_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, token_pricing_schedule: Option<TokenPricingSchedule>, public_note: Option<String>, using_group_info: Option<GroupStateTransitionInfoStatus>, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to set or update the price of a token for direct purchase.

async fn new_token_direct_purchase_transition<S: Signer<IdentityPublicKey>>( token_id: Identifier, owner_id: Identifier, data_contract_id: Identifier, token_contract_position: u16, amount: TokenAmount, total_agreed_price: Credits, identity_public_key: &IdentityPublicKey, identity_contract_nonce: IdentityNonce, user_fee_increase: UserFeeIncrease, signer: &S, platform_version: &PlatformVersion, options: Option<StateTransitionCreationOptions>, ) -> Result<StateTransition, ProtocolError>

Creates a StateTransition to perform a direct purchase of tokens by a user.

impl Encode for BatchTransition

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl FeatureVersioned for BatchTransition

fn feature_version(&self) -> FeatureVersion

impl From<BatchTransition> for StateTransition

fn from(value: BatchTransition) -> Self

Converts to this type from the input type.

impl From<BatchTransitionV0> for BatchTransition

fn from(value: BatchTransitionV0) -> Self

Converts to this type from the input type.

impl From<BatchTransitionV1> for BatchTransition

fn from(value: BatchTransitionV1) -> Self

Converts to this type from the input type.

impl JsonConvertible for BatchTransition

Available on crate features json-conversion and serde-conversion only.

fn to_json(&self) -> Result<JsonValue, ProtocolError>

fn from_json(json: JsonValue) -> Result<Self, ProtocolError>

impl OptionallyAssetLockProved for BatchTransition

fn optional_asset_lock_proof(&self) -> Option<&AssetLockProof>

Returns asset lock proof if state transition implements it

impl PartialEq for BatchTransition

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

Equality operator ==.

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

Inequality operator !=.

impl PlatformDeserializableTrusted for BatchTransition

fn deserialize_from_bytes_trusted_with_bytes_len( data: &[u8], ) -> Result<(Self, usize), ProtocolError>

where Self: Sized,

Decodes under the type’s configured byte budget, returning the value and the number of bytes it took.

fn deserialize_from_bytes_trusted_no_limit_with_bytes_len( data: &[u8], ) -> Result<(Self, usize), ProtocolError>

where Self: Sized,

Self::deserialize_from_bytes_trusted_with_bytes_len without the byte budget.

fn deserialize_from_bytes_trusted(data: &[u8]) -> Result<Self, ProtocolError>

where Self: Sized,

Decodes under the type’s configured byte budget. Bytes left over after the value are ignored; Self::deserialize_from_bytes_trusted_exact refuses them.

fn deserialize_from_bytes_trusted_no_limit( data: &[u8], ) -> Result<Self, ProtocolError>

where Self: Sized,

fn deserialize_from_bytes_trusted_exact( data: &[u8], ) -> Result<Self, ProtocolError>

where Self: Sized,

Self::deserialize_from_bytes_trusted that also refuses bytes left over after the value.

impl PlatformDeserializableUntrusted for BatchTransition

fn deserialize_from_bytes_untrusted_with_bytes_len( data: &[u8], ) -> Result<(Self, usize), ProtocolError>

where Self: Sized,

Decodes under the type’s configured byte budget, returning the value and the number of bytes it took.

fn deserialize_from_bytes_untrusted_no_limit_with_bytes_len( data: &[u8], ) -> Result<(Self, usize), ProtocolError>

where Self: Sized,

Self::deserialize_from_bytes_untrusted_with_bytes_len without the byte budget.

fn deserialize_from_bytes_untrusted(data: &[u8]) -> Result<Self, ProtocolError>

where Self: Sized,

Decodes under the type’s configured byte budget. Bytes left over after the value are ignored; Self::deserialize_from_bytes_untrusted_exact refuses them.

fn deserialize_from_bytes_untrusted_no_limit( data: &[u8], ) -> Result<Self, ProtocolError>

where Self: Sized,

fn deserialize_from_bytes_untrusted_exact( data: &[u8], ) -> Result<Self, ProtocolError>

where Self: Sized,

Self::deserialize_from_bytes_untrusted that also refuses bytes left over after the value.

impl PlatformSerializable for BatchTransition

type Error = ProtocolError

fn serialize_to_bytes(&self) -> Result<Vec<u8>, Self::Error>

fn serialize_consume_to_bytes(self) -> Result<Vec<u8>, Self::Error>

If the trait is not used just do a simple serialize

impl PlatformVersionEncode for BatchTransition

fn platform_encode<__E: Encoder>( &self, encoder: &mut __E, platform_version: &PlatformVersion, ) -> Result<(), EncodeError>

Encode a given type.

impl<'__de> PlatformVersionedBorrowDecode<'__de> for BatchTransition

fn platform_versioned_borrow_decode<__D: BorrowDecoder<'__de, Context = BincodeContext>>( decoder: &mut __D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl PlatformVersionedDecode for BatchTransition

fn platform_versioned_decode<__D: Decoder<Context = BincodeContext>>( decoder: &mut __D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Serialize for BatchTransition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Signable for BatchTransition

fn signable_bytes(&self) -> Result<Vec<u8>, ProtocolError>

impl StateTransitionEstimatedFeeValidation for BatchTransition

fn calculate_min_required_fee( &self, platform_version: &PlatformVersion, ) -> Result<Credits, ProtocolError>

Calculates the estimated minimum fee required for this state transition.

impl StateTransitionFieldTypes for BatchTransition

fn binary_property_paths() -> Vec<&'static str>

fn identifiers_property_paths() -> Vec<&'static str>

fn signature_property_paths() -> Vec<&'static str>

impl StateTransitionHasUserFeeIncrease for BatchTransition

fn user_fee_increase(&self) -> UserFeeIncrease

returns the fee multiplier

fn set_user_fee_increase(&mut self, user_fee_increase: UserFeeIncrease)

set a fee multiplier

impl StateTransitionIdentityEstimatedFeeValidation for BatchTransition

fn validate_estimated_fee( &self, identity_known_balance: Credits, platform_version: &PlatformVersion, ) -> Result<SimpleConsensusValidationResult, ProtocolError>

Validates that sufficient identity balance is available to cover the estimated fee.

impl StateTransitionIdentitySigned for BatchTransition

fn signature_public_key_id(&self) -> KeyID

fn set_signature_public_key_id(&mut self, key_id: KeyID)

fn security_level_requirement(&self, purpose: Purpose) -> Vec<SecurityLevel>

Returns minimal key security level that can be used to sign this ST. Override this method if the ST requires a different security level.

fn purpose_requirement(&self) -> Vec<Purpose>

The purpose requirement for the signing key The default is authentication However for Withdrawals and Fund Transfers the requirement is TRANSFER

fn verify_public_key_level_and_purpose( &self, public_key: &IdentityPublicKey, options: StateTransitionSigningOptions, ) -> Result<(), ProtocolError>

Verifies that the supplied public key has the correct security level and purpose to sign the state transition This should only be used for authentication

fn verify_public_key_is_enabled( &self, public_key: &IdentityPublicKey, ) -> Result<(), ProtocolError>

impl StateTransitionLike for BatchTransition

fn modified_data_ids(&self) -> Vec<Identifier>

Returns ID of the created contract

fn state_transition_type(&self) -> StateTransitionType

returns the type of State Transition

fn state_transition_protocol_version(&self) -> FeatureVersion

returns the protocol version

fn unique_identifiers(&self) -> Vec<String>

unique identifiers for the state transition This is often only one String except in the case of a documents batch state transition

fn is_document_state_transition(&self) -> bool

returns true if state transition is a document state transition

fn is_data_contract_state_transition(&self) -> bool

returns true if state transition is a data contract state transition

fn is_identity_state_transition(&self) -> bool

return true if state transition is an identity state transition

fn is_voting_state_transition(&self) -> bool

return true if state transition is a voting state transition

impl StateTransitionOwned for BatchTransition

fn owner_id(&self) -> Identifier

Get owner ID

impl StateTransitionSingleSigned for BatchTransition

fn signature(&self) -> &BinaryData

returns the signature as a byte-array

fn set_signature(&mut self, signature: BinaryData)

set a new signature

fn set_signature_bytes(&mut self, signature: Vec<u8>)

sets the signature bytes

impl StructuralPartialEq for BatchTransition

impl ValueConvertible for BatchTransition

Available on crate features serde-conversion and value-conversion only.

fn to_object(&self) -> Result<Value, ProtocolError>

where Self: Sized,

fn into_object(self) -> Result<Value, ProtocolError>

where Self: Sized,

fn from_object(value: Value) -> Result<Self, ProtocolError>

where Self: Sized,

fn from_object_ref(value: &Value) -> Result<Self, ProtocolError>

where Self: Sized,