dpp::state_transition::state_transitions::data_contract_create_transition

Struct DataContractCreateTransitionV1

pub struct DataContractCreateTransitionV1 {
    pub data_contract: DataContractInSerializationFormat,
    pub identity_nonce: IdentityNonce,
    pub contract_group: Option<ContractGroupRegistration>,
    pub contract_group_memberships: Vec<ContractGroupMembership>,
    pub user_fee_increase: UserFeeIncrease,
    pub signature_public_key_id: KeyID,
    pub signature: BinaryData,
}

Expand description

Version 1 of the data contract create transition: version 0 plus contract groups.

contract_group registers a new contract group owned by the transition’s owner (or by the owners it names); the group id is derived from the owner id and the identity nonce. contract_group_memberships adds the created contract, one of its document types, or one of its tokens to contract groups the owner may add to: groups registered earlier by an owner, or the group registered by this transition. Both are empty on a plain contract creation.

Fields§

§data_contract: DataContractInSerializationFormat§identity_nonce: IdentityNonce§contract_group: Option<ContractGroupRegistration>§contract_group_memberships: Vec<ContractGroupMembership>§user_fee_increase: UserFeeIncrease§signature_public_key_id: KeyID§signature: BinaryData

DataContractCreateTransitionV1

Struct DataContractCreateTransitionV1 Copy item path

Fields§

Trait Implementations§

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

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

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

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

impl Clone for DataContractCreateTransitionV1

fn clone(&self) -> DataContractCreateTransitionV1

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

impl DataContractCreateTransitionMethodsV0 for DataContractCreateTransitionV1

async fn new_from_data_contract<S: Signer<IdentityPublicKey>>( data_contract: DataContract, identity_nonce: IdentityNonce, identity: &PartialIdentity, key_id: KeyID, signer: &S, platform_version: &PlatformVersion, feature_version: Option<FeatureVersion>, ) -> Result<StateTransition, ProtocolError>

impl DataContractCreateTransitionMethodsV1 for DataContractCreateTransitionV1

impl Debug for DataContractCreateTransitionV1

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

impl<__Context> Decode<__Context> for DataContractCreateTransitionV1

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

impl<__Context> DecodeUntrusted<__Context> for DataContractCreateTransitionV1

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

impl<'de> Deserialize<'de> for DataContractCreateTransitionV1

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl Encode for DataContractCreateTransitionV1

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

impl FeatureVersioned for DataContractCreateTransitionV1

fn feature_version(&self) -> FeatureVersion

impl<'a> From<&'a DataContractCreateTransitionV1> for DataContractCreateTransitionV1Signable<'a>

fn from(original: &'a DataContractCreateTransitionV1) -> Self

impl From<&DataContractCreateTransitionV1> for StateTransition

fn from(value: &DataContractCreateTransitionV1) -> Self

impl From<DataContractCreateTransitionV1> for StateTransition

fn from(value: DataContractCreateTransitionV1) -> Self

impl From<DataContractCreateTransitionV1> for DataContractCreateTransition

fn from(value: DataContractCreateTransitionV1) -> Self

impl JsonSafeFields for DataContractCreateTransitionV1

impl PartialEq for DataContractCreateTransitionV1

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

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

impl Serialize for DataContractCreateTransitionV1

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

impl Signable for DataContractCreateTransitionV1

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

impl StateTransitionFieldTypes for DataContractCreateTransitionV1

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

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

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

impl StateTransitionHasUserFeeIncrease for DataContractCreateTransitionV1

fn user_fee_increase(&self) -> UserFeeIncrease

fn set_user_fee_increase(&mut self, user_fee_increase: UserFeeIncrease)

impl StateTransitionIdentitySigned for DataContractCreateTransitionV1

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>

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

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

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

impl StateTransitionLike for DataContractCreateTransitionV1

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

fn state_transition_type(&self) -> StateTransitionType

fn state_transition_protocol_version(&self) -> FeatureVersion

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

fn is_document_state_transition(&self) -> bool

fn is_data_contract_state_transition(&self) -> bool

fn is_identity_state_transition(&self) -> bool

fn is_voting_state_transition(&self) -> bool

impl StateTransitionOwned for DataContractCreateTransitionV1

fn owner_id(&self) -> Identifier

impl StateTransitionSingleSigned for DataContractCreateTransitionV1

fn signature(&self) -> &BinaryData

fn set_signature(&mut self, signature: BinaryData)

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

impl StructuralPartialEq for DataContractCreateTransitionV1

impl TryFromPlatformVersioned<CreatedDataContract> for DataContractCreateTransitionV1

type Error = ProtocolError

fn try_from_platform_versioned( value: CreatedDataContract, platform_version: &PlatformVersion, ) -> Result<Self, Self::Error>

impl TryFromPlatformVersioned<DataContract> for DataContractCreateTransitionV1

type Error = ProtocolError

fn try_from_platform_versioned( value: DataContract, platform_version: &PlatformVersion, ) -> Result<Self, Self::Error>

Auto Trait Implementations§

impl Freeze for DataContractCreateTransitionV1

Struct DataContractCreateTransitionV1

impl<'de, Context> BorrowDecode<'de, Context> for DataContractCreateTransitionV1

fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

impl<'de, Context> BorrowDecodeUntrusted<'de, Context> for DataContractCreateTransitionV1

fn borrow_decode_untrusted<D: BorrowUntrustedDecoder<'de, Context = Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

impl<Context> Decode<Context> for DataContractCreateTransitionV1

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

impl<Context> DecodeUntrusted<Context> for DataContractCreateTransitionV1

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

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

fn wrap_with_cost(self, cost: OperationCost) -> CostContext<Self>
where Self: Sized,

fn wrap_fn_cost( self, f: impl FnOnce(&Self) -> OperationCost, ) -> CostContext<Self>
where Self: Sized,

impl<'de, T> DefaultBorrowDecode<'de> for T
where T: BorrowDecode<'de, ()>,

fn borrow_decode<D>(decoder: &mut D) -> Result<Self, DecodeError>
where D: BorrowDecoder<'de, Context = ()>, Self: Sized,

impl<T> DefaultDecode for T
where T: Decode<()>,

fn decode<D>(decoder: &mut D) -> Result<Self, DecodeError>
where D: Decoder<Context = ()>, Self: Sized,

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> IntoOnNetwork<U> for T
where U: FromOnNetwork<T>,

impl<T, U> IntoPlatformVersioned<U> for T
where U: FromPlatformVersioned<T>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,