diff --git a/.github/workflows/tests-rs-workspace.yml b/.github/workflows/tests-rs-workspace.yml index 622cd5ab76d..059907144e3 100644 --- a/.github/workflows/tests-rs-workspace.yml +++ b/.github/workflows/tests-rs-workspace.yml @@ -278,15 +278,69 @@ jobs: ' } + # A derive that only generates a decoder (`DecodeUntrusted`, the + # `PlatformDeserialize` family) cannot change how a structure's + # existing fields or variants serialize, but every other derive + # stays part of the comparison: swapping `Serialize_repr` for + # `Serialize`, or dropping `Encode`, is a wire change the guard must + # keep catching. Rewrite each `#[derive(...)]` attribute, single- or + # multi-line, as one canonical line with the decoder-only derives + # removed, so a rustfmt reflow of the list is not read as a change + # either. The fields, the variants and the attributes that do shape + # the encoding (serde, repr, platform_serialize) are compared + # verbatim. + normalize_derives() { + awk ' + function flush_derive( n, i, item, out) { + n = split(buf, parts, ",") + out = "" + for (i = 1; i <= n; i++) { + item = parts[i] + gsub(/^[[:space:]]+|[[:space:]]+$/, "", item) + if (item == "" || item == "DecodeUntrusted") continue + if (item == "PlatformDeserialize" || item == "PlatformDeserializeTrusted") continue + if (item == "PlatformDeserializeUntrusted") continue + out = (out == "" ? item : out ", " item) + } + print "#[derive(" out ")]" + buf = "" + } + collecting { + if (index($0, ")]")) { + sub(/\)\].*$/, "") + buf = buf " " $0 + collecting = 0 + flush_derive() + } else { + buf = buf " " $0 + } + next + } + /^[[:space:]]*#\[derive\(/ { + sub(/^[[:space:]]*#\[derive\(/, "") + if (index($0, ")]")) { + sub(/\)\].*$/, "") + buf = $0 + flush_derive() + } else { + buf = $0 + collecting = 1 + } + next + } + { print } + ' + } + for file in $CHANGED_RS; do if [ ! -f "$file" ]; then continue; fi BASE_CONTENT=$(git show "$BASE_PARENT":"$file" 2>/dev/null || true) if [ -z "$BASE_CONTENT" ]; then continue; fi - BASE_APPEND=$(echo "$BASE_CONTENT" | extract_tagged_block "@append_only") - PR_APPEND=$(extract_tagged_block "@append_only" < "$file") - BASE_IMMUTABLE=$(echo "$BASE_CONTENT" | extract_tagged_block "@immutable") - PR_IMMUTABLE=$(extract_tagged_block "@immutable" < "$file") + BASE_APPEND=$(echo "$BASE_CONTENT" | extract_tagged_block "@append_only" | normalize_derives) + PR_APPEND=$(extract_tagged_block "@append_only" < "$file" | normalize_derives) + BASE_IMMUTABLE=$(echo "$BASE_CONTENT" | extract_tagged_block "@immutable" | normalize_derives) + PR_IMMUTABLE=$(extract_tagged_block "@immutable" < "$file" | normalize_derives) if [ -n "$BASE_APPEND" ]; then # Check for deletions, ignoring comment-only lines and the tag itself diff --git a/packages/rs-dapi/src/services/platform_service/error_mapping.rs b/packages/rs-dapi/src/services/platform_service/error_mapping.rs index 930e54e767d..7575da56d7f 100644 --- a/packages/rs-dapi/src/services/platform_service/error_mapping.rs +++ b/packages/rs-dapi/src/services/platform_service/error_mapping.rs @@ -2,7 +2,7 @@ use base64::{engine, prelude::Engine as _}; use dapi_grpc::platform::v0::{ StateTransitionBroadcastError, WaitForStateTransitionResultResponse, }; -use dpp::{consensus::ConsensusError, serialization::PlatformDeserializable}; +use dpp::{consensus::ConsensusError, serialization::PlatformDeserializableUntrusted}; use std::{fmt::Debug, str::FromStr}; use tonic::{Code, metadata::MetadataValue}; @@ -23,7 +23,7 @@ impl TenderdashStatus { pub fn new(code: i64, message: Option, consensus_error: Option>) -> Self { // sanity check: consensus_error must deserialize to ConsensusError if present if let Some(ref bytes) = consensus_error - && ConsensusError::deserialize_from_bytes(bytes).is_err() + && ConsensusError::deserialize_from_bytes_untrusted(bytes).is_err() { tracing::debug!( data = hex::encode(bytes), @@ -95,10 +95,12 @@ impl TenderdashStatus { } if let Some(consensus_error_bytes) = &self.consensus_error - && let Ok(consensus_error) = - ConsensusError::deserialize_from_bytes(consensus_error_bytes).inspect_err(|e| { - tracing::debug!("Failed to deserialize consensus error: {}", e); - }) + && let Ok(consensus_error) = ConsensusError::deserialize_from_bytes_untrusted( + consensus_error_bytes, + ) + .inspect_err(|e| { + tracing::debug!("Failed to deserialize consensus error: {}", e); + }) { return consensus_error.to_string(); } @@ -285,7 +287,7 @@ pub(super) fn decode_consensus_error(info_base64: String) -> Option> { })?; // sanity check: serialized error must deserialize to ConsensusError - if ConsensusError::deserialize_from_bytes(&serialized_error).is_err() { + if ConsensusError::deserialize_from_bytes_untrusted(&serialized_error).is_err() { tracing::debug!( data = hex::encode(&serialized_error), "Drive error info 'serializedError' failed to deserialize to ConsensusError" @@ -479,7 +481,7 @@ mod tests { setup_tracing(); let decoded = decode_consensus_error(info_base64.to_string()) .expect("decode consensus error from fixture"); - ConsensusError::deserialize_from_bytes(&decoded).expect("should deserialize"); + ConsensusError::deserialize_from_bytes_untrusted(&decoded).expect("should deserialize"); } // -- map_tenderdash_message tests -- diff --git a/packages/rs-dpp/src/address_funds/fee_strategy/mod.rs b/packages/rs-dpp/src/address_funds/fee_strategy/mod.rs index 61db79a241c..b8d165086fe 100644 --- a/packages/rs-dpp/src/address_funds/fee_strategy/mod.rs +++ b/packages/rs-dpp/src/address_funds/fee_strategy/mod.rs @@ -2,11 +2,11 @@ pub mod deduct_fee_from_inputs_and_outputs; pub use deduct_fee_from_inputs_and_outputs::FeeDeductionResult; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Eq, Hash)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Eq, Hash, DecodeUntrusted)] pub enum AddressFundsFeeStrategyStep { /// Deduct fee from a specific input address by index. /// The input must have remaining balance after its contribution to outputs. diff --git a/packages/rs-dpp/src/address_funds/platform_address.rs b/packages/rs-dpp/src/address_funds/platform_address.rs index 4d7641e71f5..77a94d5b724 100644 --- a/packages/rs-dpp/src/address_funds/platform_address.rs +++ b/packages/rs-dpp/src/address_funds/platform_address.rs @@ -3,7 +3,7 @@ use crate::address_funds::AddressWitnessVerificationOperations; use crate::prelude::AddressNonce; use crate::ProtocolError; use bech32::{Bech32m, Hrp}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::address::Payload; use dashcore::blockdata::script::ScriptBuf; use dashcore::hashes::{sha256d, Hash}; @@ -12,7 +12,9 @@ use dashcore::secp256k1::ecdsa::RecoverableSignature; use dashcore::secp256k1::Message; use dashcore::signer::CompactSignature; use dashcore::{Address, Network, PrivateKey, PubkeyHash, PublicKey, ScriptHash}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::convert::TryFrom; @@ -33,7 +35,9 @@ pub const ADDRESS_HASH_SIZE: usize = 20; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] pub enum PlatformAddress { @@ -428,9 +432,9 @@ impl PlatformAddress { /// Uses bincode deserialization which expects: 0x00 for P2pkh, 0x01 for P2sh. pub fn from_bytes(bytes: &[u8]) -> Result { let (address, _): (Self, usize) = - bincode::decode_from_slice(bytes, bincode::config::standard()).map_err(|e| { - ProtocolError::DecodingError(format!("cannot decode PlatformAddress: {}", e)) - })?; + bincode::decode_from_slice_untrusted(bytes, bincode::config::standard()).map_err( + |e| ProtocolError::DecodingError(format!("cannot decode PlatformAddress: {}", e)), + )?; Ok(address) } diff --git a/packages/rs-dpp/src/address_funds/witness.rs b/packages/rs-dpp/src/address_funds/witness.rs index 16efe7de0fd..a6f69d9933b 100644 --- a/packages/rs-dpp/src/address_funds/witness.rs +++ b/packages/rs-dpp/src/address_funds/witness.rs @@ -1,9 +1,9 @@ #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::de::{BorrowDecoder, Decoder}; +use bincode::de::BorrowDecoder; use bincode::enc::Encoder; use bincode::error::{DecodeError, EncodeError}; -use bincode::{Decode, Encode}; +use bincode::Encode; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -77,36 +77,46 @@ impl Encode for AddressWitness { } } -impl Decode for AddressWitness { - fn decode>(decoder: &mut D) -> Result { - let discriminant = u8::decode(decoder)?; - match discriminant { - 0 => { - let signature = BinaryData::decode(decoder)?; - Ok(AddressWitness::P2pkh { signature }) - } - 1 => { - let signatures = Vec::::decode(decoder)?; - if signatures.len() > MAX_P2SH_SIGNATURES { - return Err(DecodeError::OtherString(format!( - "P2SH signatures count {} exceeds maximum {}", - signatures.len(), - MAX_P2SH_SIGNATURES, - ))); +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_address_witness_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for AddressWitness { + fn $method>( + decoder: &mut D, + ) -> Result { + let discriminant = u8::$method(decoder)?; + match discriminant { + 0 => { + let signature = BinaryData::$method(decoder)?; + Ok(AddressWitness::P2pkh { signature }) + } + 1 => { + let signatures = Vec::::$method(decoder)?; + if signatures.len() > MAX_P2SH_SIGNATURES { + return Err(DecodeError::OtherString(format!( + "P2SH signatures count {} exceeds maximum {}", + signatures.len(), + MAX_P2SH_SIGNATURES, + ))); + } + let redeem_script = BinaryData::$method(decoder)?; + Ok(AddressWitness::P2sh { + signatures, + redeem_script, + }) + } + _ => Err(DecodeError::OtherString(format!( + "Invalid AddressWitness discriminant: {}", + discriminant + ))), } - let redeem_script = BinaryData::decode(decoder)?; - Ok(AddressWitness::P2sh { - signatures, - redeem_script, - }) } - _ => Err(DecodeError::OtherString(format!( - "Invalid AddressWitness discriminant: {}", - discriminant - ))), } - } + }; } +impl_address_witness_decode!(Decode, Decoder, decode, false); +impl_address_witness_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +bincode::impl_borrow_decode_untrusted!(AddressWitness); impl<'de, C> bincode::BorrowDecode<'de, C> for AddressWitness { fn borrow_decode>( diff --git a/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/mod.rs b/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/mod.rs index 2983bd18973..7522a9eb8f2 100644 --- a/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/mod.rs +++ b/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/mod.rs @@ -1,9 +1,11 @@ use crate::asset_lock::reduced_asset_lock_value::v0::AssetLockValueV0; use crate::fee::Credits; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Bytes32; use platform_version::version::PlatformVersion; @@ -17,11 +19,13 @@ pub use v0::{AssetLockValueGettersV0, AssetLockValueSettersV0}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, From, PartialEq, serde::Serialize, serde::Deserialize, + DecodeUntrusted, )] // Stored asset-lock values are decoded from GroveDB proof elements on the // client before the quorum signature is checked, so the byte budget must be @@ -234,7 +238,7 @@ mod json_convertible_tests { #[cfg(test)] mod deserialize_limit_tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; /// Bincode-encode the V0 shape by hand so the `tx_out_script` length prefix /// can claim more bytes than exist in the payload. @@ -258,7 +262,7 @@ mod deserialize_limit_tests { #[test] fn rejects_script_length_prefix_beyond_budget_without_allocating() { let payload = payload_with_script_length(8_000_000_000); - let err = AssetLockValue::deserialize_from_bytes(&payload) + let err = AssetLockValue::deserialize_from_bytes_untrusted(&payload) .expect_err("oversized length prefix must be rejected"); assert!( matches!(err, ProtocolError::MaxEncodedBytesReachedError { .. }), @@ -286,7 +290,8 @@ mod deserialize_limit_tests { ) .expect("value"); let bytes = original.serialize_to_bytes().expect("serialize"); - let recovered = AssetLockValue::deserialize_from_bytes(&bytes).expect("deserialize"); + let recovered = + AssetLockValue::deserialize_from_bytes_untrusted(&bytes).expect("deserialize"); assert_eq!(original, recovered); } } diff --git a/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/v0/mod.rs b/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/v0/mod.rs index a855bafb542..125f23612fe 100644 --- a/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/v0/mod.rs +++ b/packages/rs-dpp/src/asset_lock/reduced_asset_lock_value/v0/mod.rs @@ -1,14 +1,16 @@ use crate::fee::Credits; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Bytes32; // `initial_credit_value` / `remaining_credit_value` are `Credits` (u64) and can // exceed JS's `MAX_SAFE_INTEGER`; `#[json_safe_fields]` serializes them as // strings in human-readable JSON to avoid precision loss when crossing to JS. #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PartialEq, serde::Serialize, serde::Deserialize)] +#[derive( + Debug, Clone, Encode, Decode, PartialEq, serde::Serialize, serde::Deserialize, DecodeUntrusted, +)] pub struct AssetLockValueV0 { pub(super) initial_credit_value: Credits, pub(super) tx_out_script: Vec, diff --git a/packages/rs-dpp/src/balances/credits.rs b/packages/rs-dpp/src/balances/credits.rs index 9f9b4720551..9bbd5a42c65 100644 --- a/packages/rs-dpp/src/balances/credits.rs +++ b/packages/rs-dpp/src/balances/credits.rs @@ -10,6 +10,7 @@ use crate::prelude::BlockHeight; use crate::ProtocolError; +use bincode::{Decode, DecodeUntrusted, Encode}; use integer_encoding::VarInt; use std::collections::BTreeMap; use std::convert::TryFrom; @@ -42,7 +43,7 @@ pub const MAX_CREDITS: Credits = 9223372036854775807 as Credits; //i64 Max pub const CREDITS_PER_DUFF: Credits = 1000; /// An enum for credit operations -#[derive(Debug, Clone, Copy, PartialEq, Eq, bincode::Encode, bincode::Decode)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Encode, Decode, DecodeUntrusted)] pub enum CreditOperation { /// We are setting credit amounts SetCredits(Credits), @@ -51,7 +52,7 @@ pub enum CreditOperation { } /// An enum for credit operations in compacted address blobs -#[derive(Debug, Clone, PartialEq, Eq, bincode::Encode, bincode::Decode)] +#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, DecodeUntrusted)] pub enum BlockAwareCreditOperation { /// We are setting credit amounts - the final value after all operations SetCredits(Credits), diff --git a/packages/rs-dpp/src/balances/total_single_token_balance/mod.rs b/packages/rs-dpp/src/balances/total_single_token_balance/mod.rs index e9654758545..c446bb3b5a5 100644 --- a/packages/rs-dpp/src/balances/total_single_token_balance/mod.rs +++ b/packages/rs-dpp/src/balances/total_single_token_balance/mod.rs @@ -1,14 +1,17 @@ use crate::balances::credits::SignedTokenAmount; use crate::ProtocolError; #[cfg(feature = "fixtures-and-mocks")] -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; #[cfg(feature = "fixtures-and-mocks")] use platform_serialization::de::Decode; use std::fmt; /// A structure where the token supply and the aggregated token account balances should always be equal #[derive(Copy, Clone, Debug)] -#[cfg_attr(feature = "fixtures-and-mocks", derive(Encode, Decode))] +#[cfg_attr( + feature = "fixtures-and-mocks", + derive(Encode, Decode, DecodeUntrusted) +)] pub struct TotalSingleTokenBalance { /// the token supply pub token_supply: SignedTokenAmount, diff --git a/packages/rs-dpp/src/block/block_info/mod.rs b/packages/rs-dpp/src/block/block_info/mod.rs index e9685f5d8e3..a6d65f18f54 100644 --- a/packages/rs-dpp/src/block/block_info/mod.rs +++ b/packages/rs-dpp/src/block/block_info/mod.rs @@ -6,7 +6,7 @@ use crate::serialization::json_safe_fields; use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; use std::fmt; @@ -23,7 +23,19 @@ pub const DEFAULT_BLOCK_INFO: BlockInfo = BlockInfo { /// Block information #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] -#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize)] +#[derive( + Clone, + Copy, + Default, + Debug, + PartialEq, + Eq, + Encode, + Decode, + Serialize, + Deserialize, + DecodeUntrusted, +)] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] #[serde(rename_all = "camelCase")] pub struct BlockInfo { diff --git a/packages/rs-dpp/src/block/epoch/mod.rs b/packages/rs-dpp/src/block/epoch/mod.rs index 17852a9f1a6..e1ea6b7f222 100644 --- a/packages/rs-dpp/src/block/epoch/mod.rs +++ b/packages/rs-dpp/src/block/epoch/mod.rs @@ -1,5 +1,5 @@ use crate::{InvalidVectorSizeError, ProtocolError}; -use bincode::{BorrowDecode, Decode, Encode}; +use bincode::{BorrowDecode, Encode}; use serde::{Deserialize, Serialize}; /// Epoch key offset @@ -100,14 +100,23 @@ impl<'de> Deserialize<'de> for Epoch { } } -impl Decode for Epoch { - fn decode>( - decoder: &mut D, - ) -> Result { - let index = EpochIndex::decode(decoder)?; - Epoch::new(index).map_err(|e| bincode::error::DecodeError::OtherString(e.to_string())) - } +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_epoch_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for Epoch { + fn $method>( + decoder: &mut D, + ) -> Result { + let index = EpochIndex::$method(decoder)?; + Epoch::new(index) + .map_err(|e| bincode::error::DecodeError::OtherString(e.to_string())) + } + } + }; } +impl_epoch_decode!(Decode, Decoder, decode, false); +impl_epoch_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +bincode::impl_borrow_decode_untrusted!(Epoch); impl<'de, C> BorrowDecode<'de, C> for Epoch { fn borrow_decode>( diff --git a/packages/rs-dpp/src/block/extended_block_info/mod.rs b/packages/rs-dpp/src/block/extended_block_info/mod.rs index 99cb4bb1ea7..fd7021ab050 100644 --- a/packages/rs-dpp/src/block/extended_block_info/mod.rs +++ b/packages/rs-dpp/src/block/extended_block_info/mod.rs @@ -8,9 +8,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::version::FeatureVersion; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use serde::{Deserialize, Serialize}; pub mod v0; @@ -28,8 +30,10 @@ pub mod v0; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, From, + DecodeUntrusted, )] #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version #[serde(tag = "$formatVersion")] @@ -150,7 +154,7 @@ impl ExtendedBlockInfoV0Setters for ExtendedBlockInfo { mod tests { use super::*; use crate::block::block_info::BlockInfo; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; #[test] fn test_extended_block_info_bincode() { @@ -170,8 +174,9 @@ mod tests { PlatformSerializable::serialize_to_bytes(&block_info).expect("expected to serialize"); // Deserialize from the vector - let decoded: ExtendedBlockInfo = PlatformDeserializable::deserialize_from_bytes(&encoded) - .expect("expected to deserialize"); + let decoded: ExtendedBlockInfo = + PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(&encoded) + .expect("expected to deserialize"); assert_eq!(block_info, decoded); } diff --git a/packages/rs-dpp/src/block/extended_block_info/v0/mod.rs b/packages/rs-dpp/src/block/extended_block_info/v0/mod.rs index 6c9cd89b658..afe058d4790 100644 --- a/packages/rs-dpp/src/block/extended_block_info/v0/mod.rs +++ b/packages/rs-dpp/src/block/extended_block_info/v0/mod.rs @@ -2,12 +2,12 @@ use crate::block::block_info::BlockInfo; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; /// Extended Block information #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize)] +#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct ExtendedBlockInfoV0 { /// Basic block info diff --git a/packages/rs-dpp/src/block/extended_epoch_info/mod.rs b/packages/rs-dpp/src/block/extended_epoch_info/mod.rs index 70b95c88ad7..5168c1c636d 100644 --- a/packages/rs-dpp/src/block/extended_epoch_info/mod.rs +++ b/packages/rs-dpp/src/block/extended_epoch_info/mod.rs @@ -8,9 +8,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::util::deserializer::ProtocolVersion; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use serde::{Deserialize, Serialize}; /// Extended Epoch information @@ -25,8 +27,10 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, From, + DecodeUntrusted, )] #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version #[serde(tag = "$formatVersion")] diff --git a/packages/rs-dpp/src/block/extended_epoch_info/v0/mod.rs b/packages/rs-dpp/src/block/extended_epoch_info/v0/mod.rs index 7a67aac3e82..60f7f3fdbc6 100644 --- a/packages/rs-dpp/src/block/extended_epoch_info/v0/mod.rs +++ b/packages/rs-dpp/src/block/extended_epoch_info/v0/mod.rs @@ -2,12 +2,12 @@ use crate::block::epoch::EpochIndex; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::util::deserializer::ProtocolVersion; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; /// Extended Epoch information #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Clone, Debug, PartialEq, Encode, Decode, Serialize, Deserialize)] +#[derive(Clone, Debug, PartialEq, Encode, Decode, Serialize, Deserialize, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct ExtendedEpochInfoV0 { /// The index of the epoch diff --git a/packages/rs-dpp/src/block/finalized_epoch_info/mod.rs b/packages/rs-dpp/src/block/finalized_epoch_info/mod.rs index b759e374a72..3a6cadbaf2d 100644 --- a/packages/rs-dpp/src/block/finalized_epoch_info/mod.rs +++ b/packages/rs-dpp/src/block/finalized_epoch_info/mod.rs @@ -7,9 +7,11 @@ use crate::protocol_error::ProtocolError; use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use serde::{Deserialize, Serialize}; /// Finalized Epoch information @@ -24,8 +26,10 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, From, + DecodeUntrusted, )] #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version #[serde(tag = "$formatVersion")] diff --git a/packages/rs-dpp/src/block/finalized_epoch_info/v0/mod.rs b/packages/rs-dpp/src/block/finalized_epoch_info/v0/mod.rs index afd31521359..7475088a069 100644 --- a/packages/rs-dpp/src/block/finalized_epoch_info/v0/mod.rs +++ b/packages/rs-dpp/src/block/finalized_epoch_info/v0/mod.rs @@ -4,14 +4,14 @@ use crate::fee::Credits; use crate::prelude::{BlockHeight, BlockHeightInterval, CoreBlockHeight, TimestampMillis}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; /// Finalized Epoch information #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Clone, Debug, PartialEq, Encode, Decode, Serialize, Deserialize)] +#[derive(Clone, Debug, PartialEq, Encode, Decode, Serialize, Deserialize, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct FinalizedEpochInfoV0 { /// First block time diff --git a/packages/rs-dpp/src/core_types/validator/v0/mod.rs b/packages/rs-dpp/src/core_types/validator/v0/mod.rs index e8388544fee..e99533cc51e 100644 --- a/packages/rs-dpp/src/core_types/validator/v0/mod.rs +++ b/packages/rs-dpp/src/core_types/validator/v0/mod.rs @@ -5,14 +5,12 @@ use crate::bls_signatures::{Bls12381G2Impl, PublicKey as BlsPublicKey}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[cfg(feature = "core-types-serialization")] -use bincode::de::Decoder; #[cfg(feature = "core-types-serialization")] use bincode::enc::Encoder; #[cfg(feature = "core-types-serialization")] use bincode::error::{DecodeError, EncodeError}; #[cfg(feature = "core-types-serialization")] -use bincode::{Decode, Encode}; +use bincode::Encode; #[cfg(feature = "core-types-serialization")] use dashcore::hashes::Hash; @@ -84,58 +82,71 @@ impl Encode for ValidatorV0 { } } -#[cfg(feature = "core-types-serialization")] -impl Decode for ValidatorV0 { - fn decode>(decoder: &mut D) -> Result { - // Decode each field in the same order as they were encoded - - // Decode ProTxHash - let pro_tx_hash_bytes = <[u8; 32]>::decode(decoder)?; - let pro_tx_hash = ProTxHash::from_slice(&pro_tx_hash_bytes) - .map_err(|_| DecodeError::OtherString("Failed to decode ProTxHash".to_string()))?; - - // Decode Option - let has_public_key = bool::decode(decoder)?; - let public_key = if has_public_key { - let public_key_bytes = <[u8; 48]>::decode(decoder)?; - - Some( - BlsPublicKey::try_from(public_key_bytes.as_slice()).map_err(|_| { - DecodeError::OtherString("Failed to decode BlsPublicKey".to_string()) - })?, - ) - } else { - None - }; - - // Decode node_ip as a string - let node_ip = String::decode(decoder)?; - - // Decode node_id - let node_id_bytes = <[u8; 20]>::decode(decoder)?; - let node_id = PubkeyHash::from_slice(&node_id_bytes) - .map_err(|_| DecodeError::OtherString("Failed to decode NodeId".to_string()))?; - - // Decode core_port, platform_http_port, and platform_p2p_port as u16 - let core_port = u16::decode(decoder)?; - let platform_http_port = u16::decode(decoder)?; - let platform_p2p_port = u16::decode(decoder)?; - - // Decode is_banned as a boolean - let is_banned = bool::decode(decoder)?; - - Ok(ValidatorV0 { - pro_tx_hash, - public_key, - node_ip, - node_id, - core_port, - platform_http_port, - platform_p2p_port, - is_banned, - }) - } +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_validator_v0_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for ValidatorV0 { + fn $method>( + decoder: &mut D, + ) -> Result { + // Decode each field in the same order as they were encoded + + // Decode ProTxHash + let pro_tx_hash_bytes = <[u8; 32]>::$method(decoder)?; + let pro_tx_hash = ProTxHash::from_slice(&pro_tx_hash_bytes).map_err(|_| { + DecodeError::OtherString("Failed to decode ProTxHash".to_string()) + })?; + + // Decode Option + let has_public_key = bool::$method(decoder)?; + let public_key = if has_public_key { + let public_key_bytes = <[u8; 48]>::$method(decoder)?; + + Some( + BlsPublicKey::try_from(public_key_bytes.as_slice()).map_err(|_| { + DecodeError::OtherString("Failed to decode BlsPublicKey".to_string()) + })?, + ) + } else { + None + }; + + // Decode node_ip as a string + let node_ip = String::$method(decoder)?; + + // Decode node_id + let node_id_bytes = <[u8; 20]>::$method(decoder)?; + let node_id = PubkeyHash::from_slice(&node_id_bytes) + .map_err(|_| DecodeError::OtherString("Failed to decode NodeId".to_string()))?; + + // Decode core_port, platform_http_port, and platform_p2p_port as u16 + let core_port = u16::$method(decoder)?; + let platform_http_port = u16::$method(decoder)?; + let platform_p2p_port = u16::$method(decoder)?; + + // Decode is_banned as a boolean + let is_banned = bool::$method(decoder)?; + + Ok(ValidatorV0 { + pro_tx_hash, + public_key, + node_ip, + node_id, + core_port, + platform_http_port, + platform_p2p_port, + is_banned, + }) + } + } + }; } +#[cfg(feature = "core-types-serialization")] +impl_validator_v0_decode!(Decode, Decoder, decode, false); +#[cfg(feature = "core-types-serialization")] +impl_validator_v0_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +#[cfg(feature = "core-types-serialization")] +bincode::impl_borrow_decode_untrusted!(ValidatorV0); impl Debug for ValidatorV0 { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { diff --git a/packages/rs-dpp/src/core_types/validator_set/mod.rs b/packages/rs-dpp/src/core_types/validator_set/mod.rs index e032b4bc88d..7a14485110f 100644 --- a/packages/rs-dpp/src/core_types/validator_set/mod.rs +++ b/packages/rs-dpp/src/core_types/validator_set/mod.rs @@ -6,10 +6,12 @@ use crate::core_types::validator_set::v0::{ #[cfg(feature = "core-types-serialization")] use crate::ProtocolError; #[cfg(feature = "core-types-serialization")] -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::{ProTxHash, QuorumHash}; #[cfg(feature = "core-types-serialization")] -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -28,7 +30,14 @@ pub mod v0; )] #[cfg_attr( feature = "core-types-serialization", - derive(Encode, Decode, PlatformDeserialize, PlatformSerialize), + derive( + Encode, + Decode, + DecodeUntrusted, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize + ), platform_serialize(limit = 15000, unversioned) )] pub enum ValidatorSet { diff --git a/packages/rs-dpp/src/core_types/validator_set/v0/mod.rs b/packages/rs-dpp/src/core_types/validator_set/v0/mod.rs index f00993628f6..45a19e2224c 100644 --- a/packages/rs-dpp/src/core_types/validator_set/v0/mod.rs +++ b/packages/rs-dpp/src/core_types/validator_set/v0/mod.rs @@ -1,7 +1,7 @@ use crate::bls_signatures::PublicKey as BlsPublicKey; use crate::core_types::validator::v0::ValidatorV0; #[cfg(feature = "core-types-serialization")] -use bincode::de::{BorrowDecoder, Decoder}; +use bincode::de::BorrowDecoder; #[cfg(feature = "core-types-serialization")] use bincode::enc::Encoder; #[cfg(feature = "core-types-serialization")] @@ -98,51 +98,61 @@ impl Encode for ValidatorSetV0 { } } -#[cfg(feature = "core-types-serialization")] -impl Decode for ValidatorSetV0 { - fn decode>( - decoder: &mut D, - ) -> Result { - // Decode the quorum hash directly as a [u8; 32] array - let quorum_hash = <[u8; 32]>::decode(decoder)?; - let quorum_index = Option::::decode(decoder)?; - let core_height = u32::decode(decoder)?; - - // Decode Vec<(Vec, ValidatorV0)> and convert it back to BTreeMap - let members_as_vec = Vec::<(Vec, ValidatorV0)>::decode(decoder)?; - let members: BTreeMap = members_as_vec - .into_iter() - .map(|(key_bytes, value)| { - let key = ProTxHash::from_slice(&key_bytes).map_err(|_| { - bincode::error::DecodeError::OtherString( - "Failed to decode ProTxHash".to_string(), - ) - })?; - Ok((key, value)) - }) - .collect::>()?; - - // Decode the [u8; 48] directly - let mut public_key_bytes = [0u8; 48]; - let bytes = <[u8; 48]>::decode(decoder)?; - public_key_bytes.copy_from_slice(&bytes); - let threshold_public_key = - BlsPublicKey::try_from(public_key_bytes.as_slice()).map_err(|e| { - bincode::error::DecodeError::OtherString(format!( - "Failed to decode BlsPublicKey: {}", - e - )) - })?; - - Ok(ValidatorSetV0 { - quorum_hash: QuorumHash::from_byte_array(quorum_hash), - quorum_index, - core_height, - members, - threshold_public_key, - }) - } +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_validator_set_v0_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for ValidatorSetV0 { + fn $method>( + decoder: &mut D, + ) -> Result { + // Decode the quorum hash directly as a [u8; 32] array + let quorum_hash = <[u8; 32]>::$method(decoder)?; + let quorum_index = Option::::$method(decoder)?; + let core_height = u32::$method(decoder)?; + + // Decode Vec<(Vec, ValidatorV0)> and convert it back to BTreeMap + let members_as_vec = Vec::<(Vec, ValidatorV0)>::$method(decoder)?; + let members: BTreeMap = members_as_vec + .into_iter() + .map(|(key_bytes, value)| { + let key = ProTxHash::from_slice(&key_bytes).map_err(|_| { + bincode::error::DecodeError::OtherString( + "Failed to decode ProTxHash".to_string(), + ) + })?; + Ok((key, value)) + }) + .collect::>()?; + + // Decode the [u8; 48] directly + let mut public_key_bytes = [0u8; 48]; + let bytes = <[u8; 48]>::$method(decoder)?; + public_key_bytes.copy_from_slice(&bytes); + let threshold_public_key = BlsPublicKey::try_from(public_key_bytes.as_slice()) + .map_err(|e| { + bincode::error::DecodeError::OtherString(format!( + "Failed to decode BlsPublicKey: {}", + e + )) + })?; + + Ok(ValidatorSetV0 { + quorum_hash: QuorumHash::from_byte_array(quorum_hash), + quorum_index, + core_height, + members, + threshold_public_key, + }) + } + } + }; } +#[cfg(feature = "core-types-serialization")] +impl_validator_set_v0_decode!(Decode, Decoder, decode, false); +#[cfg(feature = "core-types-serialization")] +impl_validator_set_v0_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +#[cfg(feature = "core-types-serialization")] +bincode::impl_borrow_decode_untrusted!(ValidatorSetV0); #[cfg(feature = "core-types-serialization")] impl<'de, C> BorrowDecode<'de, C> for ValidatorSetV0 { diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/mod.rs index 3e96fee2b43..8c0f076f7d1 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/mod.rs @@ -3,7 +3,7 @@ use crate::data_contract::associated_token::token_configuration::v0::TokenConfig use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; use std::borrow::Cow; @@ -15,7 +15,9 @@ pub mod v0; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum TokenConfiguration { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs index 8aa6b50f751..5a7e57c97d2 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration/v0/mod.rs @@ -19,7 +19,7 @@ use crate::data_contract::change_control_rules::ChangeControlRules; use crate::data_contract::GroupContractPosition; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; use std::fmt; @@ -33,7 +33,7 @@ use std::fmt; /// This configuration is designed to be deterministic and versioned for compatibility /// across protocol upgrades and validation environments. #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq)] +#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct TokenConfigurationV0 { /// Metadata conventions, including decimals and localizations. @@ -248,7 +248,19 @@ impl fmt::Display for TokenConfigurationV0 { /// /// These presets are intended to be used in conjunction with `TokenConfigurationPreset` /// to simplify token setup and enforce governance constraints consistently. -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, + Deserialize, + Decode, + Encode, + Debug, + Clone, + Copy, + PartialEq, + Eq, + PartialOrd, + DecodeUntrusted, +)] pub enum TokenConfigurationPresetFeatures { /// No actions are permitted after initialization. All governance and control /// settings are immutable. @@ -292,7 +304,9 @@ pub enum TokenConfigurationPresetFeatures { /// /// This abstraction allows users to choose between common control configurations /// ranging from immutable tokens to fully administrator-controlled assets. -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[serde(rename_all = "camelCase")] pub struct TokenConfigurationPreset { /// Defines the set of capabilities enabled in this preset (e.g., whether minting, diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/mod.rs index 6c247bd5721..f4d045d3b8d 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/mod.rs @@ -3,7 +3,7 @@ use crate::data_contract::associated_token::token_configuration_convention::v0:: use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; use std::fmt; @@ -21,7 +21,19 @@ pub mod v0; /// This enum enables evolution of the convention schema over time without breaking /// compatibility with older tokens. Each variant defines a specific format version. #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, PartialOrd, From)] +#[derive( + Serialize, + Deserialize, + Encode, + Decode, + Debug, + Clone, + PartialEq, + Eq, + PartialOrd, + From, + DecodeUntrusted, +)] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] #[serde(tag = "$formatVersion")] pub enum TokenConfigurationConvention { diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/v0/mod.rs index 5c59dc52ba1..a510a0f54cf 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_convention/v0/mod.rs @@ -5,7 +5,7 @@ use crate::data_contract::associated_token::token_configuration_localization::ac use crate::data_contract::associated_token::token_configuration_localization::TokenConfigurationLocalization; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -20,7 +20,17 @@ pub const ENGLISH_ISO_639: &str = "en"; /// and does not affect consensus-critical logic or supply calculations. #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[derive( - Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, Default, + Serialize, + Deserialize, + Decode, + Encode, + Debug, + Clone, + PartialEq, + Eq, + PartialOrd, + Default, + DecodeUntrusted, )] #[serde(rename_all = "camelCase")] pub struct TokenConfigurationConventionV0 { diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_item.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_item.rs index 8729a4567e8..0476a43c43c 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_item.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_item.rs @@ -5,9 +5,11 @@ use crate::data_contract::associated_token::token_perpetual_distribution::TokenP use crate::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -21,9 +23,11 @@ use std::fmt; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PartialEq, Eq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/mod.rs index 0ec8f738abf..567c2cc2163 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/mod.rs @@ -3,7 +3,7 @@ use crate::data_contract::associated_token::token_configuration_localization::v0 use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use derive_more::From; use platform_serialization::de::Decode; use serde::{Deserialize, Serialize}; @@ -21,7 +21,19 @@ pub mod v0; /// This structure is used to map language codes to localized token names in a flexible, /// forward-compatible manner. #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, PartialOrd, From)] +#[derive( + Serialize, + Deserialize, + Encode, + Decode, + Debug, + Clone, + PartialEq, + Eq, + PartialOrd, + From, + DecodeUntrusted, +)] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] #[serde(tag = "$formatVersion")] pub enum TokenConfigurationLocalization { diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/v0/mod.rs index 6affcc7d488..86f9f36325f 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_configuration_localization/v0/mod.rs @@ -2,7 +2,7 @@ mod accessors; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; use std::fmt; @@ -12,7 +12,9 @@ use std::fmt; /// across different locales. This information is not used for validation or consensus /// but enhances UX by allowing consistent display in multilingual interfaces. #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[serde(rename_all = "camelCase")] pub struct TokenConfigurationLocalizationV0 { /// Indicates whether the token name should be capitalized when displayed. diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_distribution_key.rs b/packages/rs-dpp/src/data_contract/associated_token/token_distribution_key.rs index 9261cc24dac..00e60b7ef58 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_distribution_key.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_distribution_key.rs @@ -1,7 +1,7 @@ use crate::data_contract::associated_token::token_perpetual_distribution::distribution_recipient::{TokenDistributionRecipient, TokenDistributionResolvedRecipient}; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, Encode, DecodeUntrusted}; +use platform_serialization_derive::{PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::fmt; @@ -13,7 +13,18 @@ use crate::prelude::TimestampMillis; /// - `PreProgrammed`: A scheduled distribution with predefined rules. /// - `Perpetual`: A continuous or recurring distribution. #[derive( - Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Default, + Serialize, + Deserialize, + Decode, + Encode, + Debug, + Clone, + Copy, + PartialEq, + Eq, + PartialOrd, + Default, + DecodeUntrusted, )] pub enum TokenDistributionType { /// A pre-programmed distribution scheduled for a specific time. @@ -28,7 +39,9 @@ pub enum TokenDistributionType { /// /// - `PreProgrammed(Identifier)`: A predefined recipient for a scheduled distribution. /// - `Perpetual(TokenDistributionResolvedRecipient)`: A resolved recipient for an ongoing distribution. -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[serde( into = "TokenDistributionTypeWithResolvedRecipientRepr", from = "TokenDistributionTypeWithResolvedRecipientRepr" @@ -89,7 +102,9 @@ impl From /// - `PreProgrammed(TimestampMillis, Identifier)`: A scheduled distribution with a timestamp and recipient. /// - `Perpetual(RewardDistributionMoment, RewardDistributionMoment, TokenDistributionResolvedRecipient)`: /// A perpetual distribution with previous and next distribution moments, along with the resolved recipient. -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[serde(into = "TokenDistributionInfoRepr", from = "TokenDistributionInfoRepr")] pub enum TokenDistributionInfo { /// A pre-programmed token distribution set for a specific time. @@ -192,11 +207,13 @@ impl fmt::Display for TokenDistributionType { Decode, Encode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Debug, Clone, PartialEq, Eq, + DecodeUntrusted, )] #[platform_serialize(unversioned)] pub struct TokenDistributionKey { diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/mod.rs index 5390a106116..2d57f3870ff 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/mod.rs @@ -2,7 +2,7 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; @@ -11,7 +11,9 @@ pub mod v0; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum TokenDistributionRules { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/v0/mod.rs index 75f131f3279..ef7ef45b7fe 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_distribution_rules/v0/mod.rs @@ -7,14 +7,14 @@ use crate::data_contract::change_control_rules::v0::ChangeControlRulesV0; use crate::data_contract::change_control_rules::ChangeControlRules; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::fmt; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq)] +#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct TokenDistributionRulesV0 { #[serde(default)] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/mod.rs index 8fd9bb0e2c2..1e5798e79f9 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/mod.rs @@ -2,7 +2,7 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; @@ -11,7 +11,9 @@ pub mod v0; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, Copy, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Encode, Decode, Debug, Clone, Copy, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum TokenKeepsHistoryRules { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/v0/mod.rs index 0a47c00e4da..7baf59b5e3d 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_keeps_history_rules/v0/mod.rs @@ -1,7 +1,7 @@ mod accessors; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; use serde::{Deserialize, Serialize}; use std::fmt; @@ -10,7 +10,9 @@ use std::fmt; /// Config update, Destroying Frozen Funds, Emergency Action, /// Pre Programmed Token Release always require an entry to the ledger #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, DecodeUntrusted, +)] #[serde(rename_all = "camelCase")] pub struct TokenKeepsHistoryRulesV0 { /// Whether transfer history is recorded. diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/mod.rs index f9f99d8b8eb..f14587c6fb1 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/mod.rs @@ -2,7 +2,7 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; @@ -11,7 +11,9 @@ pub mod v0; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum TokenMarketplaceRules { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/v0/mod.rs index a1716ad19bd..e4ff1d971af 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_marketplace_rules/v0/mod.rs @@ -5,13 +5,23 @@ use crate::data_contract::change_control_rules::v0::ChangeControlRulesV0; use crate::data_contract::change_control_rules::ChangeControlRules; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; use serde::{Deserialize, Serialize}; use std::fmt; #[derive( - Serialize, Deserialize, Decode, Encode, Default, Debug, Clone, PartialEq, Eq, PartialOrd, + Serialize, + Deserialize, + Decode, + Encode, + Default, + Debug, + Clone, + PartialEq, + Eq, + PartialOrd, + DecodeUntrusted, )] pub enum TokenTradeMode { #[default] @@ -28,7 +38,7 @@ impl crate::serialization::JsonConvertible for TokenTradeMode {} impl crate::serialization::ValueConvertible for TokenTradeMode {} #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq)] +#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct TokenMarketplaceRulesV0 { pub trade_mode: TokenTradeMode, diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_function/encode.rs b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_function/encode.rs index 002cd993366..e082117d3ac 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_function/encode.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_function/encode.rs @@ -1,6 +1,6 @@ use crate::balances::credits::TokenAmount; use crate::data_contract::associated_token::token_perpetual_distribution::distribution_function::DistributionFunction; -use bincode::{BorrowDecode, Decode, Encode}; +use bincode::{BorrowDecode, Encode}; use std::collections::BTreeMap; impl Encode for DistributionFunction { @@ -151,155 +151,163 @@ impl Encode for DistributionFunction { } } -impl Decode for DistributionFunction { - fn decode>( - decoder: &mut D, - ) -> Result { - let variant = u8::decode(decoder)?; - match variant { - 0 => { - let n = TokenAmount::decode(decoder)?; - Ok(Self::FixedAmount { amount: n }) - } - 1 => { - let min = TokenAmount::decode(decoder)?; - let max = TokenAmount::decode(decoder)?; - Ok(Self::Random { min, max }) - } - 2 => { - let step_count = u32::decode(decoder)?; - let decrease_per_interval_numerator = u16::decode(decoder)?; - let decrease_per_interval_denominator = u16::decode(decoder)?; - let s = Option::::decode(decoder)?; - let max_interval_count = Option::::decode(decoder)?; - let n = TokenAmount::decode(decoder)?; - let trailing_distribution_interval_amount = TokenAmount::decode(decoder)?; - let min_value = Option::::decode(decoder)?; - Ok(Self::StepDecreasingAmount { - start_decreasing_offset: s, - decrease_per_interval_numerator, - decrease_per_interval_denominator, - step_count, - distribution_start_amount: n, - max_interval_count, - min_value, - trailing_distribution_interval_amount, - }) - } - 3 => { - let steps = BTreeMap::::decode(decoder)?; - Ok(Self::Stepwise(steps)) +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_distribution_function_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for DistributionFunction { + fn $method>( + decoder: &mut D, + ) -> Result { + let variant = u8::$method(decoder)?; + match variant { + 0 => { + let n = TokenAmount::$method(decoder)?; + Ok(Self::FixedAmount { amount: n }) + } + 1 => { + let min = TokenAmount::$method(decoder)?; + let max = TokenAmount::$method(decoder)?; + Ok(Self::Random { min, max }) + } + 2 => { + let step_count = u32::$method(decoder)?; + let decrease_per_interval_numerator = u16::$method(decoder)?; + let decrease_per_interval_denominator = u16::$method(decoder)?; + let s = Option::::$method(decoder)?; + let max_interval_count = Option::::$method(decoder)?; + let n = TokenAmount::$method(decoder)?; + let trailing_distribution_interval_amount = TokenAmount::$method(decoder)?; + let min_value = Option::::$method(decoder)?; + Ok(Self::StepDecreasingAmount { + start_decreasing_offset: s, + decrease_per_interval_numerator, + decrease_per_interval_denominator, + step_count, + distribution_start_amount: n, + max_interval_count, + min_value, + trailing_distribution_interval_amount, + }) + } + 3 => { + let steps = BTreeMap::::$method(decoder)?; + Ok(Self::Stepwise(steps)) + } + 4 => { + let a = i64::$method(decoder)?; + let d = u64::$method(decoder)?; + let s = Option::::$method(decoder)?; + let b = TokenAmount::$method(decoder)?; + let min_value = Option::::$method(decoder)?; + let max_value = Option::::$method(decoder)?; + Ok(Self::Linear { + a, + d, + start_step: s, + starting_amount: b, + min_value, + max_value, + }) + } + 5 => { + let a = i64::$method(decoder)?; + let d = u64::$method(decoder)?; + let m = i64::$method(decoder)?; + let n = u64::$method(decoder)?; + let o = i64::$method(decoder)?; + let s = Option::::$method(decoder)?; + let b = TokenAmount::$method(decoder)?; + let min_value = Option::::$method(decoder)?; + let max_value = Option::::$method(decoder)?; + Ok(Self::Polynomial { + a, + d, + m, + n, + o, + start_moment: s, + b, + min_value, + max_value, + }) + } + 6 => { + let a = u64::$method(decoder)?; + let d = u64::$method(decoder)?; + let m = i64::$method(decoder)?; + let n = u64::$method(decoder)?; + let o = i64::$method(decoder)?; + let start_moment = Option::::$method(decoder)?; + let b = TokenAmount::$method(decoder)?; + let min_value = Option::::$method(decoder)?; + let max_value = Option::::$method(decoder)?; + Ok(Self::Exponential { + a, + d, + m, + n, + o, + start_moment, + b, + min_value, + max_value, + }) + } + 7 => { + let a = i64::$method(decoder)?; + let d = u64::$method(decoder)?; + let m = u64::$method(decoder)?; + let n = u64::$method(decoder)?; + let o = i64::$method(decoder)?; + let s = Option::::$method(decoder)?; + let b = TokenAmount::$method(decoder)?; + let min_value = Option::::$method(decoder)?; + let max_value = Option::::$method(decoder)?; + Ok(Self::Logarithmic { + a, + d, + m, + n, + o, + start_moment: s, + b, + min_value, + max_value, + }) + } + 8 => { + let a = i64::$method(decoder)?; + let d = u64::$method(decoder)?; + let m = u64::$method(decoder)?; + let n = u64::$method(decoder)?; + let o = i64::$method(decoder)?; + let s = Option::::$method(decoder)?; + let b = TokenAmount::$method(decoder)?; + let min_value = Option::::$method(decoder)?; + let max_value = Option::::$method(decoder)?; + Ok(Self::InvertedLogarithmic { + a, + d, + m, + n, + o, + start_moment: s, + b, + min_value, + max_value, + }) + } + _ => Err(bincode::error::DecodeError::OtherString( + "Invalid variant".into(), + )), + } } - 4 => { - let a = i64::decode(decoder)?; - let d = u64::decode(decoder)?; - let s = Option::::decode(decoder)?; - let b = TokenAmount::decode(decoder)?; - let min_value = Option::::decode(decoder)?; - let max_value = Option::::decode(decoder)?; - Ok(Self::Linear { - a, - d, - start_step: s, - starting_amount: b, - min_value, - max_value, - }) - } - 5 => { - let a = i64::decode(decoder)?; - let d = u64::decode(decoder)?; - let m = i64::decode(decoder)?; - let n = u64::decode(decoder)?; - let o = i64::decode(decoder)?; - let s = Option::::decode(decoder)?; - let b = TokenAmount::decode(decoder)?; - let min_value = Option::::decode(decoder)?; - let max_value = Option::::decode(decoder)?; - Ok(Self::Polynomial { - a, - d, - m, - n, - o, - start_moment: s, - b, - min_value, - max_value, - }) - } - 6 => { - let a = u64::decode(decoder)?; - let d = u64::decode(decoder)?; - let m = i64::decode(decoder)?; - let n = u64::decode(decoder)?; - let o = i64::decode(decoder)?; - let start_moment = Option::::decode(decoder)?; - let b = TokenAmount::decode(decoder)?; - let min_value = Option::::decode(decoder)?; - let max_value = Option::::decode(decoder)?; - Ok(Self::Exponential { - a, - d, - m, - n, - o, - start_moment, - b, - min_value, - max_value, - }) - } - 7 => { - let a = i64::decode(decoder)?; - let d = u64::decode(decoder)?; - let m = u64::decode(decoder)?; - let n = u64::decode(decoder)?; - let o = i64::decode(decoder)?; - let s = Option::::decode(decoder)?; - let b = TokenAmount::decode(decoder)?; - let min_value = Option::::decode(decoder)?; - let max_value = Option::::decode(decoder)?; - Ok(Self::Logarithmic { - a, - d, - m, - n, - o, - start_moment: s, - b, - min_value, - max_value, - }) - } - 8 => { - let a = i64::decode(decoder)?; - let d = u64::decode(decoder)?; - let m = u64::decode(decoder)?; - let n = u64::decode(decoder)?; - let o = i64::decode(decoder)?; - let s = Option::::decode(decoder)?; - let b = TokenAmount::decode(decoder)?; - let min_value = Option::::decode(decoder)?; - let max_value = Option::::decode(decoder)?; - Ok(Self::InvertedLogarithmic { - a, - d, - m, - n, - o, - start_moment: s, - b, - min_value, - max_value, - }) - } - _ => Err(bincode::error::DecodeError::OtherString( - "Invalid variant".into(), - )), } - } + }; } +impl_distribution_function_decode!(Decode, Decoder, decode, false); +impl_distribution_function_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +bincode::impl_borrow_decode_untrusted!(DistributionFunction); impl<'de, C> BorrowDecode<'de, C> for DistributionFunction { fn borrow_decode>( diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_recipient.rs b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_recipient.rs index 9cb14dd2c3a..fbac19ec480 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_recipient.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/distribution_recipient.rs @@ -2,14 +2,24 @@ use crate::data_contract::associated_token::token_distribution_key::{ TokenDistributionType, TokenDistributionTypeWithResolvedRecipient, }; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSerialize; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::fmt; #[derive( - Decode, Encode, PlatformSerialize, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Default, + Decode, + Encode, + PlatformSerialize, + Debug, + Clone, + Copy, + PartialEq, + Eq, + PartialOrd, + Default, + DecodeUntrusted, )] #[platform_serialize(unversioned)] // Custom `Serialize` / `Deserialize` below — `derive(Serialize, Deserialize)` @@ -189,7 +199,9 @@ pub type TokenDistributionWeight = u64; // pub total_blocks: u64, // } -#[derive(Decode, Encode, PlatformSerialize, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Decode, Encode, PlatformSerialize, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[platform_serialize(unversioned)] // Custom `Serialize` / `Deserialize` below — every variant wraps `Identifier` // (a base58 string in JSON, not a map), so serde's internal tagging can't diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/mod.rs index 8ed10179900..0141343186a 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/mod.rs @@ -4,9 +4,11 @@ use crate::errors::ProtocolError; use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use serde::{Deserialize, Serialize}; use std::fmt; @@ -25,13 +27,15 @@ pub mod v0; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Debug, Clone, PartialEq, Eq, PartialOrd, From, + DecodeUntrusted, )] #[serde(tag = "$formatVersion")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_moment/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_moment/mod.rs index bbdc9bf342a..cf88f7c2199 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_moment/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_moment/mod.rs @@ -1,7 +1,7 @@ use crate::block::epoch::EpochIndex; use crate::prelude::{BlockHeight, TimestampMillis}; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, Encode, DecodeUntrusted}; +use platform_serialization_derive::{PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize}; use serde::{Deserialize, Serialize}; use std::fmt; use std::ops::{Add, Div}; @@ -13,7 +13,8 @@ use crate::ProtocolError; Serialize, Deserialize, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Decode, Encode, Debug, @@ -22,6 +23,7 @@ use crate::ProtocolError; PartialEq, Eq, PartialOrd, + DecodeUntrusted, )] #[platform_serialize(unversioned)] // serde routes through `RewardDistributionMomentRepr` to get internal `type` diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_type/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_type/mod.rs index 0949f96d16a..19e0bb5c793 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_type/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/reward_distribution_type/mod.rs @@ -4,7 +4,7 @@ mod validation; use crate::data_contract::associated_token::token_perpetual_distribution::distribution_function::{DistributionFunction, MAX_DISTRIBUTION_CYCLES_PARAM}; use crate::prelude::{BlockHeightInterval, DataContract, EpochInterval, TimestampMillisInterval}; -use bincode::{Decode, Encode}; +use bincode::{Decode, Encode, DecodeUntrusted}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use serde::{Deserialize, Serialize}; @@ -14,7 +14,9 @@ use crate::data_contract::associated_token::token_perpetual_distribution::reward use crate::ProtocolError; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[serde(tag = "$type", rename_all = "camelCase")] pub enum RewardDistributionType { /// An amount of tokens is emitted every n blocks. diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/v0/mod.rs index 861b59344bc..35974b5fdd8 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_perpetual_distribution/v0/mod.rs @@ -1,6 +1,6 @@ mod methods; -use bincode::{Encode, Decode}; +use bincode::{Encode, Decode, DecodeUntrusted}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use serde::{Deserialize, Serialize}; @@ -9,7 +9,9 @@ use crate::data_contract::associated_token::token_perpetual_distribution::distri use crate::data_contract::associated_token::token_perpetual_distribution::reward_distribution_type::RewardDistributionType; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, PartialOrd, DecodeUntrusted, +)] #[serde(rename_all = "camelCase")] pub struct TokenPerpetualDistributionV0 { /// The distribution type that the token will use diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/mod.rs index 508c3fb3ad7..4d620d7b98a 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/mod.rs @@ -3,7 +3,7 @@ use crate::data_contract::associated_token::token_pre_programmed_distribution::v use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; use std::fmt; @@ -14,7 +14,9 @@ pub mod v0; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum TokenPreProgrammedDistribution { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/v0/mod.rs b/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/v0/mod.rs index 863e7b85c27..d81c35037ac 100644 --- a/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/associated_token/token_pre_programmed_distribution/v0/mod.rs @@ -2,7 +2,7 @@ use crate::balances::credits::TokenAmount; use crate::prelude::TimestampMillis; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; use platform_value::Identifier; use serde::{Deserialize, Serialize}; @@ -10,7 +10,7 @@ use std::collections::BTreeMap; use std::fmt; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq)] +#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct TokenPreProgrammedDistributionV0 { #[cfg_attr( diff --git a/packages/rs-dpp/src/data_contract/change_control_rules/authorized_action_takers.rs b/packages/rs-dpp/src/data_contract/change_control_rules/authorized_action_takers.rs index 068f0180ff7..3f8f363a6f1 100644 --- a/packages/rs-dpp/src/data_contract/change_control_rules/authorized_action_takers.rs +++ b/packages/rs-dpp/src/data_contract/change_control_rules/authorized_action_takers.rs @@ -7,13 +7,15 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use std::fmt; -#[derive(Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Default)] +#[derive( + Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Default, DecodeUntrusted, +)] // Custom `Serialize` / `Deserialize` below — `derive(Serialize, Deserialize)` // can't produce the desired flat wire shape because the `Identity` variant // wraps `Identifier` (serializes as a base58 string, not a map) and `Group` diff --git a/packages/rs-dpp/src/data_contract/change_control_rules/mod.rs b/packages/rs-dpp/src/data_contract/change_control_rules/mod.rs index aed6523009c..7e2377a2cbd 100644 --- a/packages/rs-dpp/src/data_contract/change_control_rules/mod.rs +++ b/packages/rs-dpp/src/data_contract/change_control_rules/mod.rs @@ -10,7 +10,7 @@ use crate::group::action_taker::{ActionGoal, ActionTaker}; use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use platform_value::Identifier; use serde::{Deserialize, Serialize}; @@ -19,7 +19,9 @@ use std::fmt; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum ChangeControlRules { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/change_control_rules/v0/mod.rs b/packages/rs-dpp/src/data_contract/change_control_rules/v0/mod.rs index f0aee23a862..6236922d89f 100644 --- a/packages/rs-dpp/src/data_contract/change_control_rules/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/change_control_rules/v0/mod.rs @@ -4,14 +4,16 @@ use crate::data_contract::GroupContractPosition; use crate::group::action_taker::{ActionGoal, ActionTaker}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use std::fmt; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, Default)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, PartialEq, Eq, Default, DecodeUntrusted, +)] #[serde(rename_all = "camelCase")] pub struct ChangeControlRulesV0 { /// This is who is authorized to make such a change diff --git a/packages/rs-dpp/src/data_contract/config/mod.rs b/packages/rs-dpp/src/data_contract/config/mod.rs index 194446c4023..e8990d450a1 100644 --- a/packages/rs-dpp/src/data_contract/config/mod.rs +++ b/packages/rs-dpp/src/data_contract/config/mod.rs @@ -13,7 +13,7 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::version::PlatformVersion; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; pub use fields::*; use platform_value::Value; @@ -23,7 +23,9 @@ use v0::{DataContractConfigGettersV0, DataContractConfigSettersV0, DataContractC #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] -#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, Copy, PartialEq, Eq, From)] +#[derive( + Serialize, Deserialize, Encode, Decode, Debug, Clone, Copy, PartialEq, Eq, From, DecodeUntrusted, +)] #[serde(tag = "$formatVersion")] pub enum DataContractConfig { #[serde(rename = "0")] diff --git a/packages/rs-dpp/src/data_contract/config/v0/mod.rs b/packages/rs-dpp/src/data_contract/config/v0/mod.rs index f40f16912ac..0ff3851986f 100644 --- a/packages/rs-dpp/src/data_contract/config/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/config/v0/mod.rs @@ -9,14 +9,16 @@ use crate::data_contract::storage_requirements::keys_for_document_type::StorageK #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::btreemap_extensions::BTreeValueMapHelper; use platform_value::Value; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, DecodeUntrusted, +)] #[serde(rename_all = "camelCase", default)] pub struct DataContractConfigV0 { /// Can the contract ever be deleted. If the contract is deleted, so should be all diff --git a/packages/rs-dpp/src/data_contract/config/v1/mod.rs b/packages/rs-dpp/src/data_contract/config/v1/mod.rs index f69435e6b37..c90995f0e15 100644 --- a/packages/rs-dpp/src/data_contract/config/v1/mod.rs +++ b/packages/rs-dpp/src/data_contract/config/v1/mod.rs @@ -9,14 +9,16 @@ use crate::data_contract::storage_requirements::keys_for_document_type::StorageK #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::btreemap_extensions::BTreeValueMapHelper; use platform_value::Value; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq)] +#[derive( + Serialize, Deserialize, Decode, Encode, Debug, Clone, Copy, PartialEq, Eq, DecodeUntrusted, +)] #[serde(rename_all = "camelCase", default)] pub struct DataContractConfigV1 { /// Can the contract ever be deleted. If the contract is deleted, so should be all diff --git a/packages/rs-dpp/src/data_contract/created_data_contract/mod.rs b/packages/rs-dpp/src/data_contract/created_data_contract/mod.rs index 2059eb0fcae..8023a60bb58 100644 --- a/packages/rs-dpp/src/data_contract/created_data_contract/mod.rs +++ b/packages/rs-dpp/src/data_contract/created_data_contract/mod.rs @@ -7,12 +7,13 @@ use crate::data_contract::created_data_contract::v0::{ use crate::prelude::{DataContract, IdentityNonce}; use crate::version::PlatformVersion; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use crate::data_contract::serialized_version::DataContractInSerializationFormat; use crate::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, PlatformSerializableWithPlatformVersion, }; use crate::ProtocolError::{PlatformDeserializationError, PlatformSerializationError}; @@ -28,7 +29,7 @@ pub enum CreatedDataContract { V0(CreatedDataContractV0), } -#[derive(Clone, Debug, Encode, Decode, From)] +#[derive(Clone, Debug, Encode, Decode, From, DecodeUntrusted)] pub enum CreatedDataContractInSerializationFormat { V0(CreatedDataContractInSerializationFormatV0), } @@ -77,27 +78,16 @@ impl PlatformSerializableWithPlatformVersion for CreatedDataContract { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for CreatedDataContract { - fn versioned_deserialize( - data: &[u8], +impl CreatedDataContract { + /// Rebuilds the contract from its decoded serialization format; the + /// trusted and untrusted entry points differ only in the decoder that + /// produced `created_data_contract_in_serialization_format`. + fn from_serialization_format( + created_data_contract_in_serialization_format: CreatedDataContractInSerializationFormat, full_validation: bool, platform_version: &PlatformVersion, - ) -> Result - where - Self: Sized, - { - let config = bincode::config::standard() - .with_big_endian() - .with_no_limit(); - let created_data_contract_in_serialization_format: CreatedDataContractInSerializationFormat = - bincode::borrow_decode_from_slice(data, config) - .map_err(|e| { - PlatformDeserializationError(format!( - "unable to deserialize DataContract: {}", - e - )) - })? - .0; + method: &str, + ) -> Result { let (data_contract_in_serialization_format, identity_nonce) = created_data_contract_in_serialization_format.data_contract_and_identity_nonce_owned(); let data_contract = DataContract::try_from_platform_versioned( @@ -116,7 +106,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Cre identity_nonce, })), version => Err(ProtocolError::UnknownVersionMismatch { - method: "CreatedDataContract::versioned_deserialize".to_string(), + method: method.to_string(), known_versions: vec![0], received: version, }), @@ -124,6 +114,70 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Cre } } +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted + for CreatedDataContract +{ + fn versioned_deserialize_trusted( + data: &[u8], + full_validation: bool, + platform_version: &PlatformVersion, + ) -> Result + where + Self: Sized, + { + let config = bincode::config::standard() + .with_big_endian() + .with_no_limit(); + let created_data_contract_in_serialization_format: CreatedDataContractInSerializationFormat = + bincode::borrow_decode_from_slice(data, config) + .map_err(|e| { + PlatformDeserializationError(format!( + "unable to deserialize DataContract: {}", + e + )) + })? + .0; + Self::from_serialization_format( + created_data_contract_in_serialization_format, + full_validation, + platform_version, + "CreatedDataContract::versioned_deserialize_trusted", + ) + } +} + +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted + for CreatedDataContract +{ + fn versioned_deserialize_untrusted( + data: &[u8], + full_validation: bool, + platform_version: &PlatformVersion, + ) -> Result + where + Self: Sized, + { + let config = bincode::config::standard() + .with_big_endian() + .with_no_limit(); + let created_data_contract_in_serialization_format: CreatedDataContractInSerializationFormat = + bincode::borrow_decode_from_slice_untrusted(data, config) + .map_err(|e| { + PlatformDeserializationError(format!( + "unable to deserialize DataContract: {}", + e + )) + })? + .0; + Self::from_serialization_format( + created_data_contract_in_serialization_format, + full_validation, + platform_version, + "CreatedDataContract::versioned_deserialize_untrusted", + ) + } +} + impl From for DataContract { fn from(value: CreatedDataContract) -> Self { match value { @@ -295,7 +349,7 @@ mod tests { // ----------------------------------------------------------------------- // Bincode serialize / deserialize round-trip via // PlatformSerializableWithPlatformVersion + - // PlatformDeserializableWithPotentialValidationFromVersionedStructure. + // PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted. // ----------------------------------------------------------------------- #[test] @@ -307,8 +361,9 @@ mod tests { .expect("serialize should succeed"); assert!(!bytes.is_empty()); - let restored = CreatedDataContract::versioned_deserialize(&bytes, false, platform_version) - .expect("deserialize should succeed"); + let restored = + CreatedDataContract::versioned_deserialize_untrusted(&bytes, false, platform_version) + .expect("deserialize should succeed"); assert_eq!(restored.identity_nonce(), created.identity_nonce()); assert_eq!(restored.data_contract().id(), created.data_contract().id()); } @@ -333,8 +388,9 @@ mod tests { fn versioned_deserialize_rejects_garbage() { let platform_version = PlatformVersion::latest(); let garbage = vec![0xFFu8; 16]; - let err = CreatedDataContract::versioned_deserialize(&garbage, false, platform_version) - .expect_err("random bytes should not deserialize"); + let err = + CreatedDataContract::versioned_deserialize_untrusted(&garbage, false, platform_version) + .expect_err("random bytes should not deserialize"); match err { ProtocolError::PlatformDeserializationError(_) => {} other => panic!("expected PlatformDeserializationError, got {other:?}"), @@ -344,14 +400,48 @@ mod tests { #[test] fn versioned_deserialize_rejects_empty_input() { let platform_version = PlatformVersion::latest(); - let err = CreatedDataContract::versioned_deserialize(&[], false, platform_version) - .expect_err("empty input should not deserialize"); + let err = + CreatedDataContract::versioned_deserialize_untrusted(&[], false, platform_version) + .expect_err("empty input should not deserialize"); assert!(matches!( err, ProtocolError::PlatformDeserializationError(_) )); } + #[test] + fn versioned_deserialize_trusted_agrees_with_untrusted() { + let platform_version = PlatformVersion::latest(); + let created = sample_created(); + let bytes = created + .serialize_to_bytes_with_platform_version(platform_version) + .expect("serialize should succeed"); + + let trusted = + CreatedDataContract::versioned_deserialize_trusted(&bytes, false, platform_version) + .expect("trusted deserialize should succeed"); + let untrusted = + CreatedDataContract::versioned_deserialize_untrusted(&bytes, false, platform_version) + .expect("untrusted deserialize should succeed"); + assert_eq!(trusted, untrusted); + assert_eq!(trusted.identity_nonce(), created.identity_nonce()); + assert_eq!(trusted.data_contract().id(), created.data_contract().id()); + } + + #[test] + fn versioned_deserialize_trusted_rejects_garbage_and_empty_input() { + let platform_version = PlatformVersion::latest(); + for input in [vec![0xFFu8; 16], vec![]] { + let err = + CreatedDataContract::versioned_deserialize_trusted(&input, false, platform_version) + .expect_err("malformed input should not deserialize"); + assert!(matches!( + err, + ProtocolError::PlatformDeserializationError(_) + )); + } + } + // ----------------------------------------------------------------------- // CreatedDataContractInSerializationFormat helpers // ----------------------------------------------------------------------- @@ -369,7 +459,7 @@ mod tests { let config = bincode::config::standard() .with_big_endian() .with_no_limit(); - let (decoded, _consumed) = bincode::borrow_decode_from_slice::< + let (decoded, _consumed) = bincode::borrow_decode_from_slice_untrusted::< CreatedDataContractInSerializationFormat, _, >(&bytes, config) diff --git a/packages/rs-dpp/src/data_contract/created_data_contract/v0/mod.rs b/packages/rs-dpp/src/data_contract/created_data_contract/v0/mod.rs index 37495e20841..cf1c0e3760d 100644 --- a/packages/rs-dpp/src/data_contract/created_data_contract/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/created_data_contract/v0/mod.rs @@ -1,5 +1,5 @@ use crate::data_contract::DataContract; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use crate::data_contract::serialized_version::DataContractInSerializationFormat; use crate::prelude::IdentityNonce; @@ -11,7 +11,7 @@ pub struct CreatedDataContractV0 { pub identity_nonce: IdentityNonce, } -#[derive(Clone, Debug, Encode, Decode)] +#[derive(Clone, Debug, Encode, Decode, DecodeUntrusted)] pub struct CreatedDataContractInSerializationFormatV0 { pub data_contract: DataContractInSerializationFormat, pub identity_nonce: IdentityNonce, diff --git a/packages/rs-dpp/src/data_contract/document_type/property/mod.rs b/packages/rs-dpp/src/data_contract/document_type/property/mod.rs index 3a48552bf84..8960cdbae02 100644 --- a/packages/rs-dpp/src/data_contract/document_type/property/mod.rs +++ b/packages/rs-dpp/src/data_contract/document_type/property/mod.rs @@ -4,8 +4,10 @@ use std::convert::TryInto; use std::io::{BufReader, Cursor, Read}; use crate::data_contract::errors::DataContractError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use crate::consensus::basic::decode::DecodingError; use crate::data_contract::config::v1::DataContractConfigGettersV1; @@ -84,7 +86,17 @@ pub struct ByteArrayPropertySizes { // This enum is embedded in consensus errors, so it is consensus-serialized. // @append_only #[derive( - Debug, PartialEq, Eq, Clone, Serialize, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Debug, + PartialEq, + Eq, + Clone, + Serialize, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[serde(rename_all = "lowercase")] pub enum DocumentPropertyReferenceTarget { diff --git a/packages/rs-dpp/src/data_contract/document_type/random_document.rs b/packages/rs-dpp/src/data_contract/document_type/random_document.rs index 7797534e8dd..e91115413e0 100644 --- a/packages/rs-dpp/src/data_contract/document_type/random_document.rs +++ b/packages/rs-dpp/src/data_contract/document_type/random_document.rs @@ -1,4 +1,4 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use std::time::{SystemTime, UNIX_EPOCH}; use crate::data_contract::document_type::accessors::DocumentTypeV0Getters; @@ -19,7 +19,7 @@ use platform_value::{Bytes32, Identifier}; use rand::prelude::StdRng; use rand::SeedableRng; -#[derive(Clone, Copy, Debug, Eq, PartialEq, Encode, Decode)] +#[derive(Clone, Copy, Debug, Eq, PartialEq, Encode, Decode, DecodeUntrusted)] pub enum DocumentFieldFillType { /// Do not fill a field if that field is not required DoNotFillIfNotRequired, @@ -27,7 +27,7 @@ pub enum DocumentFieldFillType { FillIfNotRequired, } -#[derive(Clone, Copy, Debug, Eq, PartialEq, Encode, Decode)] +#[derive(Clone, Copy, Debug, Eq, PartialEq, Encode, Decode, DecodeUntrusted)] pub enum DocumentFieldFillSize { /// Fill to the min size allowed by the contract MinDocumentFillSize, diff --git a/packages/rs-dpp/src/data_contract/document_type/restricted_creation/mod.rs b/packages/rs-dpp/src/data_contract/document_type/restricted_creation/mod.rs index e875a6fe2c4..41a072796e5 100644 --- a/packages/rs-dpp/src/data_contract/document_type/restricted_creation/mod.rs +++ b/packages/rs-dpp/src/data_contract/document_type/restricted_creation/mod.rs @@ -2,11 +2,11 @@ use crate::consensus::basic::data_contract::UnknownDocumentCreationRestrictionMo use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use std::fmt; use std::fmt::{Display, Formatter}; -#[derive(Debug, PartialEq, Clone, Copy, Eq, Encode, Decode)] +#[derive(Debug, PartialEq, Clone, Copy, Eq, Encode, Decode, DecodeUntrusted)] pub enum CreationRestrictionMode { NoRestrictions, OwnerOnly, diff --git a/packages/rs-dpp/src/data_contract/document_type/v0/random_document_type.rs b/packages/rs-dpp/src/data_contract/document_type/v0/random_document_type.rs index 26231060fd9..72164db4da9 100644 --- a/packages/rs-dpp/src/data_contract/document_type/v0/random_document_type.rs +++ b/packages/rs-dpp/src/data_contract/document_type/v0/random_document_type.rs @@ -31,7 +31,7 @@ //! //! //! -#[derive(Clone, Copy, Debug, PartialEq, Encode, Decode)] +#[derive(Clone, Copy, Debug, PartialEq, Encode, Decode, DecodeUntrusted)] pub struct FieldTypeWeights { pub string_weight: u16, pub float_weight: u16, @@ -41,7 +41,7 @@ pub struct FieldTypeWeights { pub byte_array_weight: u16, } -#[derive(Clone, Debug, PartialEq, Encode, Decode)] +#[derive(Clone, Debug, PartialEq, Encode, Decode, DecodeUntrusted)] pub struct FieldMinMaxBounds { pub string_min_len: Range, pub string_has_min_len_chance: f64, @@ -63,7 +63,7 @@ pub struct FieldMinMaxBounds { pub byte_array_has_max_len_chance: f64, } -#[derive(Clone, Debug, PartialEq, Encode, Decode)] +#[derive(Clone, Debug, PartialEq, Encode, Decode, DecodeUntrusted)] pub struct RandomDocumentTypeParameters { pub new_fields_optional_count_range: Range, pub new_fields_required_count_range: Range, @@ -112,7 +112,7 @@ use crate::identity::SecurityLevel; use crate::nft::TradeMode; use crate::version::PlatformVersion; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use indexmap::IndexMap; use itertools::Itertools; use platform_value::{platform_value, Identifier}; diff --git a/packages/rs-dpp/src/data_contract/errors/contract.rs b/packages/rs-dpp/src/data_contract/errors/contract.rs index 80dee9f226f..b9ebf94e54a 100644 --- a/packages/rs-dpp/src/data_contract/errors/contract.rs +++ b/packages/rs-dpp/src/data_contract/errors/contract.rs @@ -1,8 +1,10 @@ use crate::consensus::basic::data_contract::DocumentTypesAreMissingError; use crate::consensus::basic::decode::DecodingError; use crate::consensus::basic::BasicError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::basic::document::InvalidDocumentTypeError; @@ -12,7 +14,16 @@ use crate::ProtocolError; // @append_only #[derive( - Error, Debug, PartialEq, PlatformSerialize, PlatformDeserialize, Encode, Decode, Clone, + Error, + Debug, + PartialEq, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Encode, + Decode, + Clone, + DecodeUntrusted, )] pub enum DataContractError { #[error(transparent)] diff --git a/packages/rs-dpp/src/data_contract/errors/json_schema_error.rs b/packages/rs-dpp/src/data_contract/errors/json_schema_error.rs index 6d318541080..31bdae4bb73 100644 --- a/packages/rs-dpp/src/data_contract/errors/json_schema_error.rs +++ b/packages/rs-dpp/src/data_contract/errors/json_schema_error.rs @@ -1,11 +1,23 @@ use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; // @append_only #[derive( - Error, Debug, PartialEq, Eq, PlatformSerialize, PlatformDeserialize, Encode, Decode, Clone, + Error, + Debug, + PartialEq, + Eq, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Encode, + Decode, + Clone, + DecodeUntrusted, )] pub enum JsonSchemaError { #[error("can't create json schema: {0}")] diff --git a/packages/rs-dpp/src/data_contract/extra/drive_api_tests.rs b/packages/rs-dpp/src/data_contract/extra/drive_api_tests.rs index 289c3e95290..4f8d7d7ef07 100644 --- a/packages/rs-dpp/src/data_contract/extra/drive_api_tests.rs +++ b/packages/rs-dpp/src/data_contract/extra/drive_api_tests.rs @@ -8,7 +8,7 @@ mod test { use crate::data_contract::conversion::cbor::DataContractCborConversionMethodsV0; use crate::data_contract::document_type::accessors::DocumentTypeV0Getters; use crate::data_contract::DataContract; - use crate::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use crate::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use crate::serialization::PlatformSerializableWithPlatformVersion; use crate::tests::json_document::json_document_to_contract; use assert_matches::assert_matches; @@ -330,9 +330,12 @@ mod test { let contract = contract .serialize_to_bytes_with_platform_version(platform_version) .expect("serialization shouldn't fail"); - let deserialized_contract = - DataContract::versioned_deserialize(contract.as_slice(), false, platform_version) - .expect("deserialization shouldn't fail"); + let deserialized_contract = DataContract::versioned_deserialize_untrusted( + contract.as_slice(), + false, + platform_version, + ) + .expect("deserialization shouldn't fail"); assert_eq!( deserialized_contract.as_latest().unwrap().config, diff --git a/packages/rs-dpp/src/data_contract/factory/v0/mod.rs b/packages/rs-dpp/src/data_contract/factory/v0/mod.rs index 9f463884a75..ae2ee035a8a 100644 --- a/packages/rs-dpp/src/data_contract/factory/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/factory/v0/mod.rs @@ -14,7 +14,7 @@ use crate::data_contract::serialized_version::DataContractInSerializationFormat; #[cfg(feature = "value-conversion")] use crate::data_contract::v0::DataContractV0; use crate::data_contract::{DataContract, INITIAL_DATA_CONTRACT_VERSION}; -use crate::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use crate::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; #[cfg(feature = "state-transitions")] use crate::state_transition::data_contract_create_transition::DataContractCreateTransition; #[cfg(feature = "state-transitions")] @@ -149,7 +149,7 @@ impl DataContractFactoryV0 { #[cfg(not(feature = "validation"))] let skip_validation = true; - let data_contract: DataContract = DataContract::versioned_deserialize( + let data_contract: DataContract = DataContract::versioned_deserialize_untrusted( buffer.as_slice(), !skip_validation, platform_version, diff --git a/packages/rs-dpp/src/data_contract/group/mod.rs b/packages/rs-dpp/src/data_contract/group/mod.rs index e46c58815dd..02a3dd3b62a 100644 --- a/packages/rs-dpp/src/data_contract/group/mod.rs +++ b/packages/rs-dpp/src/data_contract/group/mod.rs @@ -8,8 +8,10 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::validation::SimpleConsensusValidationResult; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use platform_version::version::PlatformVersion; use serde::{Deserialize, Serialize}; @@ -32,11 +34,13 @@ pub type GroupRequiredPower = u32; Decode, Encode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Debug, Clone, PartialEq, Eq, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[serde(tag = "$formatVersion")] diff --git a/packages/rs-dpp/src/data_contract/group/v0/mod.rs b/packages/rs-dpp/src/data_contract/group/v0/mod.rs index 14d1282a09d..cbc47a88dfe 100644 --- a/packages/rs-dpp/src/data_contract/group/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/group/v0/mod.rs @@ -11,8 +11,10 @@ use crate::data_contract::GroupContractPosition; use crate::serialization::json_safe_fields; use crate::validation::SimpleConsensusValidationResult; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use platform_version::version::PlatformVersion; use serde::{Deserialize, Serialize}; @@ -25,11 +27,13 @@ use std::collections::BTreeMap; Decode, Encode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Debug, Clone, PartialEq, Eq, + DecodeUntrusted, )] #[serde(rename_all = "camelCase")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/data_contract/mod.rs b/packages/rs-dpp/src/data_contract/mod.rs index 1fd1a6de9a9..f3f4fbb4de1 100644 --- a/packages/rs-dpp/src/data_contract/mod.rs +++ b/packages/rs-dpp/src/data_contract/mod.rs @@ -1,13 +1,17 @@ use crate::serialization::{ - PlatformDeserializableWithBytesLenFromVersionedStructure, - PlatformDeserializableWithPotentialValidationFromVersionedStructure, - PlatformLimitDeserializableFromVersionedStructure, PlatformSerializableWithPlatformVersion, + PlatformDeserializableWithBytesLenFromVersionedStructureTrusted, + PlatformDeserializableWithBytesLenFromVersionedStructureUntrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, + PlatformLimitDeserializableFromVersionedStructureTrusted, + PlatformLimitDeserializableFromVersionedStructureUntrusted, + PlatformSerializableWithPlatformVersion, }; use std::collections::BTreeMap; use derive_more::From; -use bincode::config::{BigEndian, Configuration}; +use bincode::config::{BigEndian, Config, Configuration, Limit, NoLimit, Varint}; use once_cell::sync::Lazy; pub mod errors; @@ -166,8 +170,43 @@ impl PlatformSerializableWithPlatformVersion for DataContract { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for DataContract { - fn versioned_deserialize( +/// Decodes the stored serialization format with the ordinary decoder: bytes +/// this node wrote itself (Drive state, wallet storage). +fn decode_serialization_format_trusted( + data: &[u8], + config: C, + what: &str, +) -> Result<(DataContractInSerializationFormat, usize), ProtocolError> { + bincode::borrow_decode_from_slice(data, config) + .map_err(|e| PlatformDeserializationError(format!("unable to deserialize {}: {}", what, e))) +} + +/// Decodes the serialization format with the untrusted decoder: bytes from a +/// peer, a client, a proof or a host caller. +fn decode_serialization_format_untrusted( + data: &[u8], + config: C, + what: &str, +) -> Result<(DataContractInSerializationFormat, usize), ProtocolError> { + bincode::borrow_decode_from_slice_untrusted(data, config) + .map_err(|e| PlatformDeserializationError(format!("unable to deserialize {}: {}", what, e))) +} + +fn no_limit_config() -> Configuration { + bincode::config::standard() + .with_big_endian() + .with_no_limit() +} + +fn contract_limit_config() -> Configuration> +{ + bincode::config::standard() + .with_big_endian() + .with_limit::() +} + +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted for DataContract { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -175,18 +214,28 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Dat where Self: Sized, { - let config = bincode::config::standard() - .with_big_endian() - .with_no_limit(); - let data_contract_in_serialization_format: DataContractInSerializationFormat = - bincode::borrow_decode_from_slice(data, config) - .map_err(|e| { - PlatformDeserializationError(format!( - "unable to deserialize DataContract: {}", - e - )) - })? - .0; + let (data_contract_in_serialization_format, _) = + decode_serialization_format_trusted(data, no_limit_config(), "DataContract")?; + DataContract::try_from_platform_versioned( + data_contract_in_serialization_format, + full_validation, + &mut vec![], + platform_version, + ) + } +} + +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted for DataContract { + fn versioned_deserialize_untrusted( + data: &[u8], + full_validation: bool, + platform_version: &PlatformVersion, + ) -> Result + where + Self: Sized, + { + let (data_contract_in_serialization_format, _) = + decode_serialization_format_untrusted(data, no_limit_config(), "DataContract")?; DataContract::try_from_platform_versioned( data_contract_in_serialization_format, full_validation, @@ -196,8 +245,8 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Dat } } -impl PlatformDeserializableWithBytesLenFromVersionedStructure for DataContract { - fn versioned_deserialize_with_bytes_len( +impl PlatformDeserializableWithBytesLenFromVersionedStructureTrusted for DataContract { + fn versioned_deserialize_with_bytes_len_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -205,16 +254,8 @@ impl PlatformDeserializableWithBytesLenFromVersionedStructure for DataContract { where Self: Sized, { - let config = bincode::config::standard() - .with_big_endian() - .with_no_limit(); - let (data_contract_in_serialization_format, len) = bincode::borrow_decode_from_slice::< - DataContractInSerializationFormat, - Configuration, - >(data, config) - .map_err(|e| { - PlatformDeserializationError(format!("unable to deserialize DataContract: {}", e)) - })?; + let (data_contract_in_serialization_format, len) = + decode_serialization_format_trusted(data, no_limit_config(), "DataContract")?; Ok(( DataContract::try_from_platform_versioned( data_contract_in_serialization_format, @@ -227,26 +268,65 @@ impl PlatformDeserializableWithBytesLenFromVersionedStructure for DataContract { } } -impl PlatformLimitDeserializableFromVersionedStructure for DataContract { - fn versioned_limit_deserialize( +impl PlatformDeserializableWithBytesLenFromVersionedStructureUntrusted for DataContract { + fn versioned_deserialize_with_bytes_len_untrusted( + data: &[u8], + full_validation: bool, + platform_version: &PlatformVersion, + ) -> Result<(Self, usize), ProtocolError> + where + Self: Sized, + { + let (data_contract_in_serialization_format, len) = + decode_serialization_format_untrusted(data, no_limit_config(), "DataContract")?; + Ok(( + DataContract::try_from_platform_versioned( + data_contract_in_serialization_format, + full_validation, + &mut vec![], + platform_version, + )?, + len, + )) + } +} + +impl PlatformLimitDeserializableFromVersionedStructureTrusted for DataContract { + fn versioned_limit_deserialize_trusted( data: &[u8], platform_version: &PlatformVersion, ) -> Result where Self: Sized, { - let config = bincode::config::standard() - .with_big_endian() - .with_limit::(); - let data_contract_in_serialization_format: DataContractInSerializationFormat = - bincode::borrow_decode_from_slice(data, config) - .map_err(|e| { - PlatformDeserializationError(format!( - "unable to deserialize DataContract with limit: {}", - e - )) - })? - .0; + let (data_contract_in_serialization_format, _) = decode_serialization_format_trusted( + data, + contract_limit_config(), + "DataContract with limit", + )?; + // we always want to validate when we have a limit, because limit means the data isn't coming from Drive + DataContract::try_from_platform_versioned( + data_contract_in_serialization_format, + true, + &mut vec![], + platform_version, + ) + } +} + +impl PlatformLimitDeserializableFromVersionedStructureUntrusted for DataContract { + fn versioned_limit_deserialize_untrusted( + data: &[u8], + platform_version: &PlatformVersion, + ) -> Result + where + Self: Sized, + { + let (data_contract_in_serialization_format, _) = decode_serialization_format_untrusted( + data, + contract_limit_config(), + "DataContract with limit", + )?; // we always want to validate when we have a limit, because limit means the data isn't coming from Drive DataContract::try_from_platform_versioned( data_contract_in_serialization_format, @@ -350,13 +430,21 @@ mod tests { use crate::data_contract::document_type::accessors::DocumentTypeV0Getters; use crate::data_contract::storage_requirements::keys_for_document_type::StorageKeyRequirements; use crate::data_contract::DataContract; - use crate::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; - use crate::serialization::PlatformSerializableWithPlatformVersion; + use crate::serialization::{ + PlatformDeserializableWithBytesLenFromVersionedStructureTrusted, + PlatformDeserializableWithBytesLenFromVersionedStructureUntrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, + PlatformLimitDeserializableFromVersionedStructureTrusted, + PlatformLimitDeserializableFromVersionedStructureUntrusted, + PlatformSerializableWithPlatformVersion, + }; use crate::system_data_contracts::load_system_data_contract; use crate::tests::fixtures::{ get_dashpay_contract_fixture, get_dashpay_contract_with_generalized_encryption_key_fixture, }; use crate::version::PlatformVersion; + use crate::ProtocolError; use data_contracts::SystemDataContract::Dashpay; #[test] @@ -376,12 +464,84 @@ mod tests { .default_current_version as u8 ); - let unserialized = DataContract::versioned_deserialize(&serialized, true, platform_version) - .expect("expected to deserialize data contract"); + let unserialized = + DataContract::versioned_deserialize_untrusted(&serialized, true, platform_version) + .expect("expected to deserialize data contract"); assert_eq!(data_contract, unserialized); } + /// The trusted twins run the ordinary decoder over the same serialization + /// format, so on well-formed bytes they must agree with the untrusted + /// entry points exactly, consumed length included. + #[test] + fn trusted_and_untrusted_versioned_deserialize_agree() { + let platform_version = PlatformVersion::latest(); + let data_contract = load_system_data_contract(Dashpay, platform_version) + .expect("expected dashpay contract"); + let serialized = data_contract + .serialize_to_bytes_with_platform_version(platform_version) + .expect("expected to serialize data contract"); + + let trusted = + DataContract::versioned_deserialize_trusted(&serialized, true, platform_version) + .expect("trusted deserialize"); + let untrusted = + DataContract::versioned_deserialize_untrusted(&serialized, true, platform_version) + .expect("untrusted deserialize"); + assert_eq!(trusted, untrusted); + assert_eq!(trusted, data_contract); + + let (trusted, trusted_len) = DataContract::versioned_deserialize_with_bytes_len_trusted( + &serialized, + true, + platform_version, + ) + .expect("trusted deserialize with bytes len"); + let (untrusted, untrusted_len) = + DataContract::versioned_deserialize_with_bytes_len_untrusted( + &serialized, + true, + platform_version, + ) + .expect("untrusted deserialize with bytes len"); + assert_eq!(trusted, untrusted); + assert_eq!(trusted_len, untrusted_len); + assert_eq!(trusted_len, serialized.len()); + + let trusted = + DataContract::versioned_limit_deserialize_trusted(&serialized, platform_version) + .expect("trusted limit deserialize"); + let untrusted = + DataContract::versioned_limit_deserialize_untrusted(&serialized, platform_version) + .expect("untrusted limit deserialize"); + assert_eq!(trusted, untrusted); + assert_eq!(trusted, data_contract); + } + + #[test] + fn trusted_versioned_deserialize_rejects_malformed_input() { + let platform_version = PlatformVersion::latest(); + for input in [vec![0xFFu8; 16], vec![]] { + assert!(matches!( + DataContract::versioned_deserialize_trusted(&input, true, platform_version), + Err(ProtocolError::PlatformDeserializationError(_)) + )); + assert!(matches!( + DataContract::versioned_deserialize_with_bytes_len_trusted( + &input, + true, + platform_version + ), + Err(ProtocolError::PlatformDeserializationError(_)) + )); + assert!(matches!( + DataContract::versioned_limit_deserialize_trusted(&input, platform_version), + Err(ProtocolError::PlatformDeserializationError(_)) + )); + } + } + #[test] fn test_contract_can_have_specialized_contract_encryption_decryption_keys() { let data_contract = diff --git a/packages/rs-dpp/src/data_contract/serialized_version/mod.rs b/packages/rs-dpp/src/data_contract/serialized_version/mod.rs index a71dd8cb0b7..d8bbad3a4b0 100644 --- a/packages/rs-dpp/src/data_contract/serialized_version/mod.rs +++ b/packages/rs-dpp/src/data_contract/serialized_version/mod.rs @@ -17,7 +17,7 @@ use crate::serialization::ValueConvertible; use crate::validation::operations::ProtocolValidationOperation; use crate::version::PlatformVersion; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use platform_value::{Identifier, Value}; use platform_version::{IntoPlatformVersioned, TryFromPlatformVersioned}; @@ -103,7 +103,7 @@ impl fmt::Display for DataContractMismatch { all(feature = "value-conversion", feature = "serde-conversion"), derive(ValueConvertible) )] -#[derive(Debug, Clone, Encode, Decode, PartialEq, PlatformVersioned, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, PlatformVersioned, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/data_contract/serialized_version/v0/mod.rs b/packages/rs-dpp/src/data_contract/serialized_version/v0/mod.rs index 8dc57f607b9..04a5f732334 100644 --- a/packages/rs-dpp/src/data_contract/serialized_version/v0/mod.rs +++ b/packages/rs-dpp/src/data_contract/serialized_version/v0/mod.rs @@ -7,7 +7,7 @@ use crate::data_contract::v1::DataContractV1; use crate::data_contract::{DataContract, DefinitionName, DocumentName}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::{Identifier, Value}; use platform_version::version::PlatformVersion; use platform_version::FromPlatformVersioned; @@ -15,7 +15,7 @@ use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct DataContractInSerializationFormatV0 { /// A unique identifier for the data contract. diff --git a/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs b/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs index f6bcfe52aba..974eac8a382 100644 --- a/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs +++ b/packages/rs-dpp/src/data_contract/serialized_version/v1/mod.rs @@ -14,7 +14,7 @@ use crate::identity::TimestampMillis; use crate::prelude::BlockHeight; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::{Identifier, Value}; use platform_version::version::PlatformVersion; use platform_version::FromPlatformVersioned; @@ -22,7 +22,7 @@ use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, DecodeUntrusted)] #[serde(rename_all = "camelCase")] pub struct DataContractInSerializationFormatV1 { /// A unique identifier for the data contract. diff --git a/packages/rs-dpp/src/data_contract/storage_requirements/keys_for_document_type.rs b/packages/rs-dpp/src/data_contract/storage_requirements/keys_for_document_type.rs index 0b1838d4cc3..17876c17dd7 100644 --- a/packages/rs-dpp/src/data_contract/storage_requirements/keys_for_document_type.rs +++ b/packages/rs-dpp/src/data_contract/storage_requirements/keys_for_document_type.rs @@ -2,14 +2,25 @@ use crate::consensus::basic::data_contract::UnknownStorageKeyRequirementsError; use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde_repr::*; use std::convert::TryFrom; /// The Storage Key requirements // @append_only #[repr(u8)] -#[derive(Serialize_repr, Deserialize_repr, Debug, PartialEq, Eq, Copy, Clone, Encode, Decode)] +#[derive( + Serialize_repr, + Deserialize_repr, + Debug, + PartialEq, + Eq, + Copy, + Clone, + Encode, + Decode, + DecodeUntrusted, +)] pub enum StorageKeyRequirements { Unique = 0, Multiple = 1, diff --git a/packages/rs-dpp/src/data_contract/v0/serialization/mod.rs b/packages/rs-dpp/src/data_contract/v0/serialization/mod.rs index a17abd6d74d..4c30f2648d4 100644 --- a/packages/rs-dpp/src/data_contract/v0/serialization/mod.rs +++ b/packages/rs-dpp/src/data_contract/v0/serialization/mod.rs @@ -172,7 +172,7 @@ mod tests { use crate::identity::accessors::IdentityGettersV0; use crate::identity::Identity; use crate::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, PlatformSerializableWithPlatformVersion, }; use crate::tests::fixtures::get_data_contract_fixture; @@ -192,7 +192,7 @@ mod tests { .serialize_to_bytes_with_platform_version(LATEST_PLATFORM_VERSION) .expect("expected to serialize"); let recovered_contract = - DataContract::versioned_deserialize(&bytes, false, platform_version) + DataContract::versioned_deserialize_untrusted(&bytes, false, platform_version) .expect("expected to deserialize state transition"); assert_eq!(contract, recovered_contract); } diff --git a/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs b/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs index dadcf2f8256..9f9fe20333e 100644 --- a/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs +++ b/packages/rs-dpp/src/data_contract/v1/serialization/mod.rs @@ -201,7 +201,7 @@ mod tests { use crate::identity::accessors::IdentityGettersV0; use crate::identity::Identity; use crate::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, PlatformSerializableWithPlatformVersion, }; use crate::tests::fixtures::get_data_contract_fixture; @@ -222,7 +222,7 @@ mod tests { .serialize_to_bytes_with_platform_version(LATEST_PLATFORM_VERSION) .expect("expected to serialize"); let recovered_contract = - DataContract::versioned_deserialize(&bytes, false, platform_version) + DataContract::versioned_deserialize_untrusted(&bytes, false, platform_version) .expect("expected to deserialize state transition"); assert_eq!(contract, recovered_contract); } diff --git a/packages/rs-dpp/src/document/document_factory/v0/mod.rs b/packages/rs-dpp/src/document/document_factory/v0/mod.rs index faf131c8d5f..64c9a2dc451 100644 --- a/packages/rs-dpp/src/document/document_factory/v0/mod.rs +++ b/packages/rs-dpp/src/document/document_factory/v0/mod.rs @@ -311,7 +311,7 @@ impl DocumentFactoryV0 { // &self, // buffer: impl AsRef<[u8]>, // ) -> Result { - // let document = ::deserialize(buffer.as_ref()) + // let document = ::deserialize(buffer.as_ref()) // .map_err(|e| { // ConsensusError::BasicError(BasicError::SerializedObjectParsingError( // SerializedObjectParsingError::new(format!("Decode protocol entity: {:#?}", e)), diff --git a/packages/rs-dpp/src/document/extended_document/v0/serialize.rs b/packages/rs-dpp/src/document/extended_document/v0/serialize.rs index af70e8784cc..ede1c74fbd7 100644 --- a/packages/rs-dpp/src/document/extended_document/v0/serialize.rs +++ b/packages/rs-dpp/src/document/extended_document/v0/serialize.rs @@ -14,7 +14,7 @@ use crate::document::serialization_traits::{ }; use crate::serialization::{ - PlatformDeserializableWithBytesLenFromVersionedStructure, + PlatformDeserializableWithBytesLenFromVersionedStructureUntrusted, PlatformSerializableWithPlatformVersion, }; use crate::version::PlatformVersion; @@ -56,7 +56,7 @@ impl ExtendedDocumentPlatformDeserializationMethodsV0 for ExtendedDocumentV0 { platform_version: &PlatformVersion, ) -> Result { // first we deserialize the contract - let (data_contract, offset) = DataContract::versioned_deserialize_with_bytes_len( + let (data_contract, offset) = DataContract::versioned_deserialize_with_bytes_len_untrusted( serialized_extended_document, true, //since this would only happen on the client, we should validate platform_version, diff --git a/packages/rs-dpp/src/document/specialized_document_factory/v0/mod.rs b/packages/rs-dpp/src/document/specialized_document_factory/v0/mod.rs index 014c5d5afea..de24b1b04d6 100644 --- a/packages/rs-dpp/src/document/specialized_document_factory/v0/mod.rs +++ b/packages/rs-dpp/src/document/specialized_document_factory/v0/mod.rs @@ -318,7 +318,7 @@ impl SpecializedDocumentFactoryV0 { // &self, // buffer: impl AsRef<[u8]>, // ) -> Result { - // let document = ::deserialize(buffer.as_ref()) + // let document = ::deserialize(buffer.as_ref()) // .map_err(|e| { // ConsensusError::BasicError(BasicError::SerializedObjectParsingError( // SerializedObjectParsingError::new(format!("Decode protocol entity: {:#?}", e)), diff --git a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs index d1bed746659..0c9cf818655 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/basic_error.rs @@ -1,6 +1,8 @@ use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::basic::data_contract::data_contract_max_depth_exceed_error::DataContractMaxDepthExceedError; @@ -117,7 +119,16 @@ use crate::data_contract::errors::DataContractError; #[allow(clippy::large_enum_variant)] #[derive( - Error, Debug, PlatformSerialize, PlatformDeserialize, Encode, Decode, PartialEq, Clone, + Error, + Debug, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Encode, + Decode, + PartialEq, + Clone, + DecodeUntrusted, )] pub enum BasicError { /* diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_on_mutable_document_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_on_mutable_document_type_error.rs index def757d547f..70aaa7b6846 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_on_mutable_document_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_on_mutable_document_type_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Document type '{document_type}' has a contested unique index '{contested_unique_index_name}' but is set as mutable which is not allowed" diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_with_unique_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_with_unique_index_error.rs index cfaa8b9fe12..5fc2eca5af2 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_with_unique_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/contested_unique_index_with_unique_index_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Document type '{document_type}' has a contested unique index '{contested_unique_index_name}' and a unique index '{unique_index_name}' as well which is not allowed" diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs index e97ccb2f0a0..68920fc9814 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_have_new_unique_index_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document with type {document_type} has a new unique index named '{index_name}'. Adding unique indices during Data Contract update is not allowed.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs index 2eeebfb0ce0..1a07530bcab 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_immutable_properties_update_error.rs @@ -1,14 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Value; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("only $defs, version and documents fields are allowed to be updated. Forbidden operation '{operation}' on '{field_path}'")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs index 52f4633e2ad..2dc6c0952af 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_index_definition_update_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document with type {document_type} could not add or remove '{index_path}' during data contract update as we do not allow modifications of data contract index paths")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_required_fields_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_required_fields_update_error.rs index db524161d38..1c98a0c24cd 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_required_fields_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_invalid_required_fields_update_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document type {document_type} required fields update is not allowed: {details}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs index dd539edc469..b2fc17d68c6 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_max_depth_exceed_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("JSON Schema depth is greater than {max_depth:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_token_configuration_update_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_token_configuration_update_error.rs index a367fb8ad20..8539ce0a727 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_token_configuration_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_token_configuration_update_error.rs @@ -1,14 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::data_contract::associated_token::token_configuration::TokenConfiguration; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Forbidden operation '{operation}' on '{field_path}', old config is {old_config}, new config is {new_config}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs index 31150163eb8..57b88f6e8ed 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/data_contract_unique_indices_changed_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document with type {document_type} has updated unique index named '{index_name}'. Change of unique indices is not allowed")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/document_types_are_missing_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/document_types_are_missing_error.rs index 1492ee2ebe4..bf6ea035204 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/document_types_are_missing_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/document_types_are_missing_error.rs @@ -1,16 +1,27 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; use crate::prelude::Identifier; use crate::data_contract::errors::DataContractError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract {data_contract_id} must have at least one document type or token defined.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs index 7d56cf7876a..979c52a4545 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Duplicate '{index_name}' index definition for '{document_type}' document")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs index cbafd8e8e6b..89c3df9eceb 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_index_name_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Duplicate index name '{duplicate_index_name}' defined in '{document_type}' document")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_keywords_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_keywords_error.rs index c84d918cf36..4295a6f7b1e 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_keywords_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/duplicate_keywords_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data contract {data_contract_id} has duplicated keyword '{keyword}'.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_exceeds_max_members_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_exceeds_max_members_error.rs index adc124655ad..f4a4af0f62a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_exceeds_max_members_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_exceeds_max_members_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Group exceeds the maximum allowed number of members: {max_members}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_has_too_few_members_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_has_too_few_members_error.rs index 8fb5f1d325d..67183b29918 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_has_too_few_members_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_has_too_few_members_error.rs @@ -2,13 +2,26 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use std::error::Error; use std::fmt; /// Error indicating that a group contains too few members to be valid. -#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize)] +#[derive( + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, +)] #[platform_serialize(unversioned)] pub struct GroupHasTooFewMembersError { group_id: Option, diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_of_zero_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_of_zero_error.rs index 4d3b9c37d8f..53a26020940 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_of_zero_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_of_zero_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identifier::Identifier; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Member {member_id} has a power of 0, which is not allowed")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_over_limit_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_over_limit_error.rs index 40bbd70a607..ffa2d83f47a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_over_limit_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_member_has_power_over_limit_error.rs @@ -3,12 +3,24 @@ use crate::consensus::ConsensusError; use crate::data_contract::group::GroupMemberPower; use crate::errors::ProtocolError; use crate::identifier::Identifier; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Member {member_id} has a power of {power}, which exceeds the allowed limit of {max_power}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_non_unilateral_member_power_has_less_than_required_power_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_non_unilateral_member_power_has_less_than_required_power_error.rs index 7d8632fc533..f5abf2ab1a7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_non_unilateral_member_power_has_less_than_required_power_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_non_unilateral_member_power_has_less_than_required_power_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::group::GroupMemberPower; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("The collective power of non-unilateral members {total_power} is less than the required power {required_power}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_position_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_position_does_not_exist_error.rs index 7f525489363..6e144bd434b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_position_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_position_does_not_exist_error.rs @@ -2,13 +2,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; /// Error raised when a group position does not exist in the data contract. #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Group position {} does not exist", missing_group_position)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_required_power_is_invalid_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_required_power_is_invalid_error.rs index b36462efd56..69971400807 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_required_power_is_invalid_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_required_power_is_invalid_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::group::GroupRequiredPower; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Debug, Error, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Debug, + Error, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error("The required group power {required_power} is invalid. It must be > 0 and <= {max_power}.")] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_total_power_has_less_than_required_power_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_total_power_has_less_than_required_power_error.rs index 6559f20e5c0..0b4d39bf0fe 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_total_power_has_less_than_required_power_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/group_total_power_has_less_than_required_power_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::group::GroupMemberPower; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Group total power {total_power} is less than the required power {required_power}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs index 9a75c009495..1e44a8dc87c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_data_contract_schema_error.rs @@ -1,15 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; use crate::prelude::Identifier; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract updated schema is not backward compatible with one defined in Data Contract with id {data_contract_id}. Field: '{field_path}', Operation: '{operation}'" )] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_document_type_schema_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_document_type_schema_error.rs index 2dd41eb12e4..c5e97a661d3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_document_type_schema_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_document_type_schema_error.rs @@ -1,14 +1,25 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Updated document type '{document_type_name}' schema is not backward compatible with previous version. Incompatible change '{operation}' of property '{property_path}'" )] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs index 37573de69f8..35638beeb94 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/incompatible_re2_pattern_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Pattern '{pattern}' at '{path}' is not not compatible with Re2: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs index 663a961e75a..ad2e71d258f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_compound_index_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("All or none of unique compound properties must be set for '{index_name}' index of '{document_type}' document")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs index bf98afb6836..92040d2bbeb 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_id_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract Id must be {}, got {}", bs58::encode(expected_id).into_string(), bs58::encode(invalid_id).into_string())] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_version_error.rs index 02fde1a679c..284c61a65ad 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_version_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_data_contract_version_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract version must be {expected_version}, got {version}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs index 5554da1ac4e..99e3daa8c2d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_description_length_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data contract {} has description with invalid length: '{}'. Valid length is between 3 and 100 characters.", data_contract_id, description.len())] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_name_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_name_error.rs index 8b9a8bf1c76..58b604aaaaa 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_name_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_name_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("document type name '{name}' is not supported. It must be from 1 to 64 alphanumeric chars, and '_' or '-'.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_required_security_level.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_required_security_level.rs index dae65b27284..ccf4555f324 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_required_security_level.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_document_type_required_security_level.rs @@ -1,16 +1,28 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::identity::SecurityLevel; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid document type security level error security level: got {security_level:?} for {contract_id}::{document_type_name}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs index 49a531680d3..234aad95852 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_index_property_type_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("'{property_name}' property of '{document_type}' document has an invalid type '{property_type}' and cannot be use as an index")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs index e73ea6e26c3..384ed05ee2e 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_indexed_property_constraint_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Indexed property '{property_name}' for '{document_type}' document has an invalid constraint '{constraint_name}', reason: '{reason}'")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs index 0b30d024486..2a909824485 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_json_schema_ref_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid JSON Schema $ref: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_character_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_character_error.rs index 48e02d3431c..dd0ddea9183 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_character_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_character_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data contract {data_contract_id} has a keyword with invalid characters. Keywords must not contain whitespace or control characters.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_length_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_length_error.rs index 40988ef52ce..c41c2fafd02 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_length_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_keyword_length_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data contract {data_contract_id} has keyword with invalid length: '{keyword}'. Valid length is between 3 and 50 characters.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_base_supply_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_base_supply_error.rs index 738be8b2223..8993fe8a949 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_base_supply_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_base_supply_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token base supply. Given base supply: {}, Max allowed base supply: {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_divide_by_zero_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_divide_by_zero_error.rs index 0d61950a806..3a36628e6d2 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_divide_by_zero_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_divide_by_zero_error.rs @@ -1,15 +1,27 @@ use crate::consensus::basic::BasicError; use crate::data_contract::associated_token::token_perpetual_distribution::distribution_function::DistributionFunction; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token distribution function: division by zero in {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_incoherence_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_incoherence_error.rs index 3224b76e8df..43b6c48099f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_incoherence_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_incoherence_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Incoherent parameters in token distribution function: {}", message)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_error.rs index 22d269abe16..dee9a35000d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid parameter `{}` in token distribution function. Expected range: {} to {}{}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_tuple_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_tuple_error.rs index 39d0d444a0c..0f50cb8fa6f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_tuple_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_distribution_function_invalid_parameter_tuple_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid parameter tuple in token distribution function: `{}` must be {} `{}`", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_language_code_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_language_code_error.rs index a5a6d0d03c9..616673d0322 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_language_code_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_language_code_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid token language code: '{language_code}'")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_character_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_character_error.rs index a15763539d1..13f0a30a86a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_character_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_character_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data contract has a token name {token_name} in {form} with invalid characters. Token names must not contain whitespace or control characters.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_length_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_length_error.rs index 333ec475fd0..bc48ad539a7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_length_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/invalid_token_name_length_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token {form} length was {actual}, but must be between {min} and {max} characters.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/keywords_over_limit.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/keywords_over_limit.rs index 9a0b6b20481..fb24e394973 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/keywords_over_limit.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/keywords_over_limit.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Data contract {data_contract_id} has too many keywords: '{keywords_len}'. The maximum is 50." diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/main_group_is_not_defined.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/main_group_is_not_defined.rs index 83fc8bd3c7f..ec2cb748d62 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/main_group_is_not_defined.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/main_group_is_not_defined.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Main group is not defined.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/new_tokens_destination_identity_option_required_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/new_tokens_destination_identity_option_required_error.rs index cb23fc8e522..a1cb18dae31 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/new_tokens_destination_identity_option_required_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/new_tokens_destination_identity_option_required_error.rs @@ -2,13 +2,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("token configuration requires a new tokens destination identity if choosing destination is not allowed for contract {contract_id} at position {token_position}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_group_positions_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_group_positions_error.rs index 3409e866f8c..06809d83a1b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_group_positions_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_group_positions_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Contract Group Positions are not contiguous. Missing position: {}, Followed position: {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_token_positions_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_token_positions_error.rs index 2875f2bb420..ec644103b77 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_token_positions_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/non_contiguous_contract_token_positions_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Contract Token Positions are not contiguous. Missing position: {}, Followed position: {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/redundant_document_paid_for_by_token_with_contract_id.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/redundant_document_paid_for_by_token_with_contract_id.rs index 70d672829a6..258a55876cd 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/redundant_document_paid_for_by_token_with_contract_id.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/redundant_document_paid_for_by_token_with_contract_id.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document paid for by a token has a contractId {contract_id} set, which is redundant because it is targeting the current contract")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs index 2eb3ccf7a2c..bcf0eda0f33 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/system_property_index_already_present_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("System property '{property_name}' is already indexed and can't be used in '{index_name}' index of '{document_type}' document")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_decimals_over_limit_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_decimals_over_limit_error.rs index 88159657f6b..6354e189139 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_decimals_over_limit_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_decimals_over_limit_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data contract is trying to define a token with {decimals} decimal places, which exceeds the maximum allowed: {max_decimals}.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_payment_by_burning_only_allowed_on_internal_token_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_payment_by_burning_only_allowed_on_internal_token_error.rs index 65fcd8ed0a7..2923a8c3c1e 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_payment_by_burning_only_allowed_on_internal_token_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/token_payment_by_burning_only_allowed_on_internal_token_error.rs @@ -3,14 +3,26 @@ use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::tokens::calculate_token_id; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use std::fmt; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] pub struct TokenPaymentByBurningOnlyAllowedOnInternalTokenError { diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs index bf4297aaaa9..c954ceb598a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/undefined_index_property_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("'{property_name}' property is not defined in the '{document_type}' document")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs index e136354d260..6fd54777648 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unique_indices_limit_reached_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("'{document_type}' document has more than '{index_limit}' unique indexes (contested is {is_contested_limit})")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_action_token_effect_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_action_token_effect_error.rs index f7820172795..51a8679d331 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_action_token_effect_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_action_token_effect_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized document action token effect: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_creation_restriction_mode_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_creation_restriction_mode_error.rs index 2d55df7e397..c961b399e73 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_creation_restriction_mode_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_document_creation_restriction_mode_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized document creation restriction mode: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_gas_fees_paid_by_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_gas_fees_paid_by_error.rs index bd9dbbd4e4f..c81c63fc206 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_gas_fees_paid_by_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_gas_fees_paid_by_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized gas fees paid by mode: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_security_level_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_security_level_error.rs index 325c5641106..7426f9094d1 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_security_level_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_security_level_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized security level: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_storage_key_requirements_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_storage_key_requirements_error.rs index 82d00e70371..36133e62c1a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_storage_key_requirements_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_storage_key_requirements_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized storage key requirements: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_trade_mode_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_trade_mode_error.rs index bbf57f33351..9d8f343efd3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_trade_mode_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_trade_mode_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized trade mode: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_transferable_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_transferable_type_error.rs index 0ed1a89d4cf..2dc6839834b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_transferable_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/data_contract/unknown_transferable_type_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unrecognized transferable type: allowed {:?}, got {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/decoding_error.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/decoding_error.rs index 6f3bb18e9f2..f625d33c712 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/decode/decoding_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/decoding_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; use crate::data_contract::errors::DataContractError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Decoding error: {error}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs index c64e379c0ba..31e3e3fa34c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/protocol_version_parsing_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Can't read protocol version from serialized object: {parsing_error}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/serialized_object_parsing_error.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/serialized_object_parsing_error.rs index c415b41e939..5cb5ee8fd7b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/decode/serialized_object_parsing_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/serialized_object_parsing_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Parsing of serialized object failed due to: {parsing_error}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/decode/version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/decode/version_error.rs index 013204d5ded..379aecd2e81 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/decode/version_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/decode/version_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Can't read protocol version from serialized object: {error}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/contested_documents_temporarily_not_allowed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/contested_documents_temporarily_not_allowed_error.rs index 55e01ad27a2..1fae8a115cf 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/contested_documents_temporarily_not_allowed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/contested_documents_temporarily_not_allowed_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::block::epoch::EpochIndex; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Contested documents are not allowed until epoch {target_epoch}. Current epoch is {current_epoch}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/data_contract_not_present_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/data_contract_not_present_error.rs index 7ae01a0df1a..c7363800374 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/data_contract_not_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/data_contract_not_present_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract {data_contract_id} is not present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/document_creation_not_allowed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/document_creation_not_allowed_error.rs index 5ad1732dddc..bbd95c298c1 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/document_creation_not_allowed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/document_creation_not_allowed_error.rs @@ -2,13 +2,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::document_type::restricted_creation::CreationRestrictionMode; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document Creation on {data_contract_id}:{document_type_name} is not allowed because of the document type's creation restriction mode {creation_restriction_mode}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/document_field_max_size_exceeded_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/document_field_max_size_exceeded_error.rs index 358d7fd3987..9e6c1082d2a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/document_field_max_size_exceeded_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/document_field_max_size_exceeded_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Document field {field} size {actual_size_bytes} is more than system maximum {max_size_bytes}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/document_transitions_are_absent_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/document_transitions_are_absent_error.rs index 854a530cb31..b92715e58a3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/document_transitions_are_absent_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/document_transitions_are_absent_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Documents Batch Transition has no document transitions")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs index 45fbb67a838..ff37d2ac545 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_ids_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document transitions with duplicate IDs {:?}", references)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs index 6100b5128ce..720d5fddb0a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/duplicate_document_transitions_with_indices_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Document transitions with duplicate unique properties: {:?}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/identity_contract_nonce_out_of_bounds_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/identity_contract_nonce_out_of_bounds_error.rs index 54eee70ff2c..2bf4f4820b2 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/identity_contract_nonce_out_of_bounds_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/identity_contract_nonce_out_of_bounds_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::prelude::IdentityNonce; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Nonce is out of bounds: {}", nonce)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs index 2a2c9c8944d..659fa211702 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/inconsistent_compound_index_data_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Unique compound index properties {:?} are partially set for {document_type}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs index 5097d8b0734..98c27aeef82 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_action_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document transition action {} is not supported", action)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs index 094703cfcee..4b229ff0e95 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_transition_id_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::prelude::Identifier; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid document transition id {}, expected {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs index 066cc3304dd..5ef20fc1213 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/invalid_document_type_error.rs @@ -1,15 +1,27 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::prelude::Identifier; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract {data_contract_id} doesn't define document with the type {document_type}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/max_documents_transitions_exceeded_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/max_documents_transitions_exceeded_error.rs index 549ae5d3fc6..1e61d11a12b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/max_documents_transitions_exceeded_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/max_documents_transitions_exceeded_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Amount of document transitions must be less or equal to {max_transitions}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/missing_data_contract_id_basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/missing_data_contract_id_basic_error.rs index 67e53ca26eb..50d65a2a607 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/missing_data_contract_id_basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/missing_data_contract_id_basic_error.rs @@ -1,8 +1,10 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( @@ -15,7 +17,9 @@ use thiserror::Error; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("$dataContractId is not present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_action_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_action_error.rs index 502633dbb93..40be866a298 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_action_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_action_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("$action is not present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_type_error.rs index 65e1703c86b..65fab3d6e9c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_transition_type_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("$type is not present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_type_error.rs index 3130733ef6e..70c423a8ca5 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/missing_document_type_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("$type is not present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/document/missing_positions_in_document_type_properties_error.rs b/packages/rs-dpp/src/errors/consensus/basic/document/missing_positions_in_document_type_properties_error.rs index ff520b8ffb6..0eccdf0d5b1 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/document/missing_positions_in_document_type_properties_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/document/missing_positions_in_document_type_properties_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; #[derive( @@ -17,7 +19,9 @@ use platform_value::Identifier; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "position field is not present for document type \"{}\"", diff --git a/packages/rs-dpp/src/errors/consensus/basic/group/group_action_not_allowed_on_transition_error.rs b/packages/rs-dpp/src/errors/consensus/basic/group/group_action_not_allowed_on_transition_error.rs index 8f2862fa9ab..2a1451145ed 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/group/group_action_not_allowed_on_transition_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/group/group_action_not_allowed_on_transition_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Group action is not allowed during transition: {}", transition_type)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/data_contract_bounds_not_present_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/data_contract_bounds_not_present_error.rs index c6dcfc1d4ea..b6a1a328d92 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/data_contract_bounds_not_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/data_contract_bounds_not_present_error.rs @@ -1,11 +1,13 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use thiserror::Error; -#[derive(Error, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)] +#[derive( + Error, Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode, DecodeUntrusted, +)] #[error("Data Contract {data_contract_id} expected bounds are not present")] pub struct DataContractBoundsNotPresentError { /* diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/disabling_key_id_also_being_added_in_same_transition_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/disabling_key_id_also_being_added_in_same_transition_error.rs index 4d37c1e4e70..89a068b0dd7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/disabling_key_id_also_being_added_in_same_transition_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/disabling_key_id_also_being_added_in_same_transition_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Disabling a key with id {key_id:?} that is being added in same state transition")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_basic_error.rs index 19a313d702c..60dba6df7ce 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_basic_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Duplicated public keys {duplicated_ids:?} found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_basic_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_basic_error.rs index cf95281b69a..95672c03590 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_basic_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_basic_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Duplicated public key ids {duplicated_ids:?} found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs index 12b433973cb..014d4f09d61 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs @@ -1,13 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::Txid; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, )] #[error("`Instant Lock transaction {instant_lock_transaction_id:?} and Asset lock transaction {asset_lock_transaction_id:?} mismatch`")] #[platform_serialize(unversioned)] @@ -46,3 +57,15 @@ impl From for ConsensusErr Self::BasicError(BasicError::IdentityAssetLockProofLockedTransactionMismatchError(err)) } } + +impl DecodeUntrusted for IdentityAssetLockProofLockedTransactionMismatchError { + fn decode_untrusted>( + decoder: &mut D, + ) -> Result { + Ok(Self { + instant_lock_transaction_id: crate::serialization::untrusted::decode_txid(decoder)?, + asset_lock_transaction_id: crate::serialization::untrusted::decode_txid(decoder)?, + }) + } +} +bincode::impl_borrow_decode_untrusted!(IdentityAssetLockProofLockedTransactionMismatchError); diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_state_transition_replay_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_state_transition_replay_error.rs index 8c1e8ab9401..ba9762f9da0 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_state_transition_replay_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_state_transition_replay_error.rs @@ -1,14 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::Txid; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Bytes32; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, )] #[error("Asset lock transaction {transaction_id} is trying to be replayed and will be discarded")] #[platform_serialize(unversioned)] @@ -54,3 +65,16 @@ impl From for ConsensusError { Self::BasicError(BasicError::IdentityAssetLockStateTransitionReplayError(err)) } } + +impl DecodeUntrusted for IdentityAssetLockStateTransitionReplayError { + fn decode_untrusted>( + decoder: &mut D, + ) -> Result { + Ok(Self { + transaction_id: crate::serialization::untrusted::decode_txid(decoder)?, + output_index: DecodeUntrusted::decode_untrusted(decoder)?, + state_transition_id: DecodeUntrusted::decode_untrusted(decoder)?, + }) + } +} +bincode::impl_borrow_decode_untrusted!(IdentityAssetLockStateTransitionReplayError); diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_is_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_is_not_found_error.rs index b4d39d261c3..eb770a4110c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_is_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_is_not_found_error.rs @@ -1,15 +1,27 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use std::fmt::{Display, Formatter}; use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] pub struct IdentityAssetLockTransactionIsNotFoundError { diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_already_consumed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_already_consumed_error.rs index 250d2fc72cc..86085898124 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_already_consumed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_already_consumed_error.rs @@ -1,13 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::Txid; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, )] #[error("Asset lock transaction {transaction_id} output {output_index} already completely used")] #[platform_serialize(unversioned)] @@ -45,3 +56,15 @@ impl From for Consensu Self::BasicError(BasicError::IdentityAssetLockTransactionOutPointAlreadyConsumedError(err)) } } + +impl DecodeUntrusted for IdentityAssetLockTransactionOutPointAlreadyConsumedError { + fn decode_untrusted>( + decoder: &mut D, + ) -> Result { + Ok(Self { + transaction_id: crate::serialization::untrusted::decode_txid(decoder)?, + output_index: DecodeUntrusted::decode_untrusted(decoder)?, + }) + } +} +bincode::impl_borrow_decode_untrusted!(IdentityAssetLockTransactionOutPointAlreadyConsumedError); diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_not_enough_balance_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_not_enough_balance_error.rs index 98db7c70539..1536cf00f50 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_not_enough_balance_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_not_enough_balance_error.rs @@ -2,13 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::fee::Credits; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::Txid; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, )] #[error("Asset lock transaction {transaction_id} output {output_index} only has {credits_left} credits left out of {initial_asset_lock_credits} initial credits on the asset lock but needs {credits_required} credits to start processing")] #[platform_serialize(unversioned)] @@ -70,3 +81,18 @@ impl From for Consens Self::BasicError(BasicError::IdentityAssetLockTransactionOutPointNotEnoughBalanceError(err)) } } + +impl DecodeUntrusted for IdentityAssetLockTransactionOutPointNotEnoughBalanceError { + fn decode_untrusted>( + decoder: &mut D, + ) -> Result { + Ok(Self { + transaction_id: crate::serialization::untrusted::decode_txid(decoder)?, + output_index: DecodeUntrusted::decode_untrusted(decoder)?, + initial_asset_lock_credits: DecodeUntrusted::decode_untrusted(decoder)?, + credits_left: DecodeUntrusted::decode_untrusted(decoder)?, + credits_required: DecodeUntrusted::decode_untrusted(decoder)?, + }) + } +} +bincode::impl_borrow_decode_untrusted!(IdentityAssetLockTransactionOutPointNotEnoughBalanceError); diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_output_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_output_not_found_error.rs index 6f191742153..1f178f0e5d4 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_output_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_output_not_found_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Asset Lock Transaction Output with index {output_index} not found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_too_many_inputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_too_many_inputs_error.rs index 1047aeea1b3..964e5e6ce91 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_too_many_inputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_asset_lock_transaction_too_many_inputs_error.rs @@ -1,13 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, Encode, Decode, PlatformSerialize, PlatformDeserialize, PartialEq, + Error, + Debug, + Clone, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PartialEq, + DecodeUntrusted, )] #[error("Asset lock transaction has too many inputs: {actual_inputs} (max {max_inputs}). Consolidate UTXOs before creating the asset lock.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_credit_transfer_to_self_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_credit_transfer_to_self_error.rs index 5330a50619d..5b03c9eb105 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/identity_credit_transfer_to_self_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/identity_credit_transfer_to_self_error.rs @@ -1,8 +1,10 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( @@ -14,8 +16,10 @@ use thiserror::Error; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Default, + DecodeUntrusted, )] #[error("Credits transfer recipient must be another identity")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_core_chain_height_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_core_chain_height_error.rs index c1708fa455b..7fe65622249 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_core_chain_height_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_core_chain_height_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Asset Lock proof core chain height {proof_core_chain_locked_height:?} is higher than the current consensus core height {current_core_chain_locked_height:?}.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs index 9b9cb76b123..95309b7b062 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Core chain locked height {proof_core_chain_locked_height:?} must be higher than block {transaction_height:?} with Asset Lock transaction")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_transaction_output_return_size.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_transaction_output_return_size.rs index d0967509242..3d950d2dd93 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_transaction_output_return_size.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_transaction_output_return_size.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Asset Lock output {output_index} has invalid public key hash. Must be 20 length bytes hash" diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs index d4cfcb5a3a8..2de0345691f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_core_fee_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Core fee per byte {core_fee_per_byte:?} must be part of fibonacci sequence and not less than {min_core_fee_per_byte:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs index a1c816cad8f..162721d1e73 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_credit_withdrawal_transition_output_script_error.rs @@ -1,15 +1,27 @@ use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::identity::core_script::CoreScript; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Output script must be either p2pkh or p2sh")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_proof_chain_lock_validation_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_proof_chain_lock_validation_error.rs index d8ddeb3f628..398d10918e3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_proof_chain_lock_validation_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_proof_chain_lock_validation_error.rs @@ -1,11 +1,22 @@ use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::Txid; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, )] #[error("`Chain Locked transaction {transaction_id:?} could not be validated for the given height {height_reported_not_locked}`")] #[platform_serialize(unversioned)] @@ -32,3 +43,15 @@ impl InvalidIdentityAssetLockProofChainLockValidationError { self.height_reported_not_locked } } + +impl DecodeUntrusted for InvalidIdentityAssetLockProofChainLockValidationError { + fn decode_untrusted>( + decoder: &mut D, + ) -> Result { + Ok(Self { + transaction_id: crate::serialization::untrusted::decode_txid(decoder)?, + height_reported_not_locked: DecodeUntrusted::decode_untrusted(decoder)?, + }) + } +} +bincode::impl_borrow_decode_untrusted!(InvalidIdentityAssetLockProofChainLockValidationError); diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_error.rs index 344a55633df..49b0014c2f3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_error.rs @@ -1,13 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, Encode, Decode, PlatformSerialize, PlatformDeserialize, PartialEq, + Error, + Debug, + Clone, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PartialEq, + DecodeUntrusted, )] #[error("Invalid asset lock transaction: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_output_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_output_error.rs index 495f8d7e494..b8d9dad32e2 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_output_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_asset_lock_transaction_output_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Asset lock output {output_index} is not a valid standard OP_RETURN output")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_transfer_amount_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_transfer_amount_error.rs index 7099006d3aa..acf84774ede 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_transfer_amount_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_transfer_amount_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Credit transfer amount {amount} must be greater or equal to {min_amount}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_amount_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_amount_error.rs index 11b91aba7e7..c38d567f7c9 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_amount_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_credit_withdrawal_transition_amount_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Credit withdrawal amount {amount} must be greater or equal to {min_amount} and less than {max_amount}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs index cd61cf61fdf..1d371ee2a0f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_key_signature_error.rs @@ -1,15 +1,27 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::identity::KeyID; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity key {public_key_id} has invalid signature")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_data_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_data_error.rs index 5e051fbe5f1..f4d9625f99c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_data_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_data_error.rs @@ -3,12 +3,24 @@ use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; use crate::PublicKeyValidationError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid identity public key {public_key_id:?} data: {validation_error:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs index 0ee3d80b8d0..79aa3a39ac7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs @@ -1,15 +1,27 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::identity::{KeyID, Purpose, SecurityLevel}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid identity public key {public_key_id:?} security level: purpose {purpose:?} allows only for {allowed_security_levels:?} security levels, but got {security_level:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_disable_keys_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_disable_keys_error.rs index 81bff1d14a2..21b7ea2b602 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_disable_keys_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_disable_keys_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Update Transition must specify timestamp when disabling keys")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_empty_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_empty_error.rs index 03048789878..f5051926e51 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_empty_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_identity_update_transition_empty_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Update Transition neither contains new public keys or key ids to disable")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_error.rs index dabe336c605..6ad9cfe46d9 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid instant lock proof: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_signature_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_signature_error.rs index 49403c91643..2bdc6e7235b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_signature_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_instant_asset_lock_proof_signature_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Instant lock proof signature is invalid or wasn't created recently. Please try chain asset lock proof instead.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_key_purpose_for_contract_bounds_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_key_purpose_for_contract_bounds_error.rs index 6014425b53c..4290fd3fcb5 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_key_purpose_for_contract_bounds_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/invalid_key_purpose_for_contract_bounds_error.rs @@ -1,15 +1,27 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; use crate::identity::Purpose; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Key purpose {given_key_purpose} is not allowed for contract bounds. Allowed purposes: {allowed_key_purposes:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/missing_master_public_key_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/missing_master_public_key_error.rs index aa1b95eccc7..08279ed040d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/missing_master_public_key_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/missing_master_public_key_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity doesn't contain any master key, thus can not be updated. Please add a master key" diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs index b0738aaeffc..fc5478fbe43 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/not_implemented_credit_withdrawal_transition_pooling_error.rs @@ -1,14 +1,26 @@ use crate::consensus::basic::BasicError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "pooling {pooling:?} should be equal to 0. Other pooling mechanism are not implemented yet" diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/too_many_master_public_key_error.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/too_many_master_public_key_error.rs index 0b8bda2d2c0..99dc8e1f1e7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/too_many_master_public_key_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/too_many_master_public_key_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity is trying to be created with more than one master key. Please only use one master key." diff --git a/packages/rs-dpp/src/errors/consensus/basic/identity/withdrawal_output_script_not_allowed_when_signing_with_owner_key.rs b/packages/rs-dpp/src/errors/consensus/basic/identity/withdrawal_output_script_not_allowed_when_signing_with_owner_key.rs index 70f4c68b5dc..5e5f371a1f9 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/identity/withdrawal_output_script_not_allowed_when_signing_with_owner_key.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/identity/withdrawal_output_script_not_allowed_when_signing_with_owner_key.rs @@ -1,5 +1,7 @@ use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::basic::BasicError; @@ -7,10 +9,20 @@ use crate::consensus::ConsensusError; use crate::identity::core_script::CoreScript; use crate::identity::KeyID; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Withdrawal output script not allowed when signing with owner key {key_id}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/incompatible_protocol_version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/incompatible_protocol_version_error.rs index 19a781fc37e..ffdc346fbb5 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/incompatible_protocol_version_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/incompatible_protocol_version_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Protocol version {parsed_protocol_version:?} is not supported. Minimal supported protocol version is {minimal_protocol_version:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs b/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs index 72f9562a985..507fc3a7f91 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/invalid_identifier_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid {identifier_name}: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/json_schema_compilation_error.rs b/packages/rs-dpp/src/errors/consensus/basic/json_schema_compilation_error.rs index 5b40054e7f2..b9f57a398ae 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/json_schema_compilation_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/json_schema_compilation_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("JsonSchema compilation error: {compilation_error}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/json_schema_error/error.rs b/packages/rs-dpp/src/errors/consensus/basic/json_schema_error/error.rs index 780998dc297..ce66a1108f8 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/json_schema_error/error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/json_schema_error/error.rs @@ -3,17 +3,28 @@ use crate::consensus::basic::json_schema_error::error_data::JsonSchemaErrorData; use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "json-schema-validation")] use jsonschema::ValidationError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Value; #[cfg(feature = "json-schema-validation")] use serde_json::Value as JsonValue; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("JsonSchemaError: {error_summary}, path: {instance_path}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/overflow_error.rs b/packages/rs-dpp/src/errors/consensus/basic/overflow_error.rs index 9d478a9123b..abdd8aa2015 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/overflow_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/overflow_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Overflow error")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_duplicate_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_duplicate_error.rs index ea3585efc30..a847cc3cec2 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_duplicate_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_duplicate_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Fee strategy contains duplicate entries")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_empty_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_empty_error.rs index 55df295caca..16a2c133e3b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_empty_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_empty_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Fee strategy must have at least one step")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_index_out_of_bounds_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_index_out_of_bounds_error.rs index 22d851c3878..edbd7516ca3 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_index_out_of_bounds_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_index_out_of_bounds_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Fee strategy {strategy_type} index {index} is out of bounds (count: {count})")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_too_many_steps_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_too_many_steps_error.rs index 8d24436f351..f5d8b091e42 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_too_many_steps_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/fee_strategy_too_many_steps_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Fee strategy has {actual_steps} steps, maximum allowed is {max_steps}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_below_minimum_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_below_minimum_error.rs index 8b463e33ec2..2083dbf9ef8 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_below_minimum_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_below_minimum_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Input amount {input_amount} is below minimum {minimum_amount}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_output_balance_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_output_balance_mismatch_error.rs index bc8e1961574..4ca1eda35da 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_output_balance_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_output_balance_mismatch_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Input and output credits must be equal: inputs={input_sum}, outputs={output_sum}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_witness_count_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_witness_count_mismatch_error.rs index cf8eb4ac6cf..57e60bf622a 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_witness_count_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/input_witness_count_mismatch_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Number of inputs ({input_count}) does not match number of witnesses ({witness_count})")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/inputs_not_less_than_outputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/inputs_not_less_than_outputs_error.rs index 6a9b77e74af..54289416bf1 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/inputs_not_less_than_outputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/inputs_not_less_than_outputs_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Inputs must be less than outputs for identity funding: input_sum={input_sum} but should be at least minimum_difference={minimum_difference} less than output_sum={output_sum}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/insufficient_funding_amount_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/insufficient_funding_amount_error.rs index 54d3493646b..7e5a434d009 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/insufficient_funding_amount_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/insufficient_funding_amount_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Insufficient funding amount: funding_amount={funding_amount} is less than minimum={minimum_funding_amount}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_remainder_output_count_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_remainder_output_count_error.rs index 9c5a4d7d4f3..fc461ba8c48 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_remainder_output_count_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_remainder_output_count_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Exactly one output must have None value (remainder recipient), found {actual_count}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs index 0059dbcb1a6..6e44adf9862 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid State Transition type {transition_type}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/missing_state_transition_type_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/missing_state_transition_type_error.rs index 54e6ebc6dac..861244dd99f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/missing_state_transition_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/missing_state_transition_type_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("State transition type is not present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_address_also_input_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_address_also_input_error.rs index 041e14a9a56..b1375505074 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_address_also_input_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_address_also_input_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Output address cannot also be an input address")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_below_minimum_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_below_minimum_error.rs index 89642e9f6fa..ef7cffea95e 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_below_minimum_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/output_below_minimum_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Output amount {output_amount} is below minimum {minimum_amount}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/outputs_not_greater_than_inputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/outputs_not_greater_than_inputs_error.rs index f00bda92c3c..afd20864865 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/outputs_not_greater_than_inputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/outputs_not_greater_than_inputs_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Outputs must be greater than inputs for asset lock funding: inputs={input_sum}, outputs={output_sum}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_empty_proof_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_empty_proof_error.rs index 93204cdd3bf..5a55b0e2c6f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_empty_proof_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_empty_proof_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Shielded transition proof must not be empty")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_encrypted_note_size_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_encrypted_note_size_mismatch_error.rs index e091503a933..4bb5cf6adbc 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_encrypted_note_size_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_encrypted_note_size_mismatch_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Shielded action encrypted_note has invalid size: expected {expected_size} bytes, got {actual_size} bytes" diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_implicit_fee_cap_exceeded_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_implicit_fee_cap_exceeded_error.rs index 23c6b1a4180..23ab1bc65a0 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_implicit_fee_cap_exceeded_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_implicit_fee_cap_exceeded_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::fee::Credits; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("asset-lock surplus {surplus} exceeds the implicit fee cap {cap}; set a surplus_output address to receive the remainder")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_denomination_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_denomination_error.rs index 99122c6862b..ca452834f9d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_denomination_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_denomination_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid shielded identity-create denomination {denomination}: must be one of the allowed exit denominations")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_value_balance_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_value_balance_error.rs index 77cc5176e88..774fc579c64 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_value_balance_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_invalid_value_balance_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid shielded value_balance: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_no_actions_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_no_actions_error.rs index c1ebe75b5f7..139fe9e55ea 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_no_actions_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_no_actions_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Shielded transition must have at least one action")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_too_many_actions_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_too_many_actions_error.rs index 7b7218a79fd..093609a0f01 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_too_many_actions_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_too_many_actions_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Shielded transition has {actual_actions} actions, which exceeds the maximum allowed {max_actions}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_zero_anchor_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_zero_anchor_error.rs index 10761119e9c..01ddd7cb45f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_zero_anchor_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/shielded_zero_anchor_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Shielded transition anchor must not be all zeros")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs index 8d33a1999d1..c86384eac48 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("State transition size {actual_size_bytes} is more than maximum {max_size_bytes}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_not_active_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_not_active_error.rs index 735eb49be62..3fe130463e6 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_not_active_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/state_transition_not_active_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_version::version::ProtocolVersion; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "State transition type {state_transition_type} is not yet active. Current protocol version is {current_protocol_version}, required protocol version is {required_protocol_version}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_inputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_inputs_error.rs index 98c1238a83a..07f097364dc 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_inputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_inputs_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("State transition must have at least one input")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_outputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_outputs_error.rs index f3e0d83f0a7..743ad89f8d7 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_outputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_no_outputs_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("State transition must have at least one output")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_inputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_inputs_error.rs index 172fe89c9c3..0e9a25e8c5e 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_inputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_inputs_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "State transition has {actual_inputs} inputs, which exceeds the maximum allowed {max_inputs}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_outputs_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_outputs_error.rs index fb021845adf..39d452ddebe 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_outputs_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/transition_over_max_outputs_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("State transition has {actual_outputs} outputs, which exceeds the maximum allowed {max_outputs}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_balance_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_balance_mismatch_error.rs index 5df80f2350b..02d165b595c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_balance_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_balance_mismatch_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Withdrawal balance mismatch: inputs={input_sum} must equal output={output_sum} + withdrawal={withdrawal_amount}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_below_min_amount_error.rs b/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_below_min_amount_error.rs index 7372a9f184d..83f25fb4e78 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_below_min_amount_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/state_transition/withdrawal_below_min_amount_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Withdrawal amount {withdrawal_amount} must be at least {min_amount} and at most {max_amount}" diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/choosing_token_mint_recipient_not_allowed_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/choosing_token_mint_recipient_not_allowed_error.rs index 9d5f2dfc901..3f7d48efa8b 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/choosing_token_mint_recipient_not_allowed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/choosing_token_mint_recipient_not_allowed_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Choosing token mint recipient not allowed for token {}", token_id)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/contract_has_no_tokens_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/contract_has_no_tokens_error.rs index 3fc49a2600a..27bfb47964c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/contract_has_no_tokens_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/contract_has_no_tokens_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Contract {} has no tokens", contract_id)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/destination_identity_for_token_minting_not_set_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/destination_identity_for_token_minting_not_set_error.rs index 7136a46e66f..7c4eff86c8e 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/destination_identity_for_token_minting_not_set_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/destination_identity_for_token_minting_not_set_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Destination identity for minting not set for token {}", token_id)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_action_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_action_id_error.rs index 51587ab3926..cb6c238e969 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_action_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_action_id_error.rs @@ -2,11 +2,23 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::prelude::Identifier; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid action id {}, expected {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_amount_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_amount_error.rs index 4cb99622467..1990cf807ef 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_amount_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_amount_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token amount {}, should be between 1 and maximum allowed {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_config_update_no_change_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_config_update_no_change_error.rs index cb20e90e5b1..62e1dff7f68 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_config_update_no_change_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_config_update_no_change_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid token configuration update: no changes were made")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_block_interval_too_short_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_block_interval_too_short_error.rs index 4fbf382449c..abc0bd2f504 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_block_interval_too_short_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_block_interval_too_short_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::prelude::BlockHeightInterval; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("BlockBasedDistribution interval is too short: {interval}. It is below the network-required minimum.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_not_minute_aligned_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_not_minute_aligned_error.rs index e67424c3b4f..24d58ed63eb 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_not_minute_aligned_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_not_minute_aligned_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::prelude::TimestampMillisInterval; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("TimeBasedDistribution interval {interval} is not divisible by 60,000 ms (1 minute).")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_too_short_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_too_short_error.rs index f9f2aed9ba4..b56ed9644d9 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_too_short_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_distribution_time_interval_too_short_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::prelude::TimestampMillisInterval; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("TimeBasedDistribution interval is too short: {interval}. Minimum allowed is 3,600,000 ms (1 hour).")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_id_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_id_error.rs index 635f126158f..d96fd77f326 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_id_error.rs @@ -2,11 +2,23 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::prelude::Identifier; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token id {}, expected {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_note_too_big_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_note_too_big_error.rs index 30e289021c8..591ef02e0c4 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_note_too_big_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_note_too_big_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token note: '{}' is too long ({} bytes), max allowed is {} bytes", diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_position_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_position_error.rs index e131d553cd1..044a727b741 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_position_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/invalid_token_position_error.rs @@ -2,12 +2,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token position: {invalid_token_position}. {max_token_message}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/missing_default_localization.rs b/packages/rs-dpp/src/errors/consensus/basic/token/missing_default_localization.rs index 71e444a26a2..a669a205015 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/missing_default_localization.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/missing_default_localization.rs @@ -1,11 +1,23 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Missing english ('en') localization which is using by default")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/token_note_only_allowed_on_proposer_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/token_note_only_allowed_on_proposer_error.rs index e4fe3991767..cf9120dff5c 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/token_note_only_allowed_on_proposer_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/token_note_only_allowed_on_proposer_error.rs @@ -1,12 +1,24 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token note is only allowed when the signer is the proposer")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/token_pricing_schedule_empty_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/token_pricing_schedule_empty_error.rs index 93bc0d3aa72..9909a7b5050 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/token_pricing_schedule_empty_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/token_pricing_schedule_empty_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Token {} pricing schedule cannot be set to an empty set of prices", diff --git a/packages/rs-dpp/src/errors/consensus/basic/token/token_transfer_to_ourselves_error.rs b/packages/rs-dpp/src/errors/consensus/basic/token/token_transfer_to_ourselves_error.rs index dbd1ee747c1..aefa8e034d0 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/token/token_transfer_to_ourselves_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/token/token_transfer_to_ourselves_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Token transfer to the same identity is not allowed. Token ID: {}, Identity ID: {}", diff --git a/packages/rs-dpp/src/errors/consensus/basic/unsupported_feature_error.rs b/packages/rs-dpp/src/errors/consensus/basic/unsupported_feature_error.rs index 0a0c542e2b8..0d48c2b503d 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/unsupported_feature_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/unsupported_feature_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("feature {feature_name} is not supported. This validation was done in protocol version {current_protocol_version}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/basic/unsupported_protocol_version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/unsupported_protocol_version_error.rs index 610cc30c49a..8c35756e7a9 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/unsupported_protocol_version_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/unsupported_protocol_version_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Protocol version {parsed_protocol_version:?} is not supported. Latest supported version is {latest_version:?}")] #[platform_serialize(unversioned)] @@ -47,7 +59,7 @@ impl From for ConsensusError { #[cfg(test)] mod tests { use super::*; - use crate::serialization::PlatformDeserializable; + use crate::serialization::PlatformDeserializableUntrusted; use crate::serialization::PlatformSerializableWithPlatformVersion; use platform_version::version::LATEST_PLATFORM_VERSION; @@ -62,7 +74,8 @@ mod tests { .expect("should serialize"); let recovered_consensus_error = - ConsensusError::deserialize_from_bytes(&serialized_bytes).expect("should deserialize"); + ConsensusError::deserialize_from_bytes_untrusted(&serialized_bytes) + .expect("should deserialize"); assert_eq!(consensus_error, recovered_consensus_error); } diff --git a/packages/rs-dpp/src/errors/consensus/basic/unsupported_version_error.rs b/packages/rs-dpp/src/errors/consensus/basic/unsupported_version_error.rs index 5ec01d3bdbb..1af4bef3975 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/unsupported_version_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/unsupported_version_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("version {received_version:?} is not supported. Supported versions are {min_version:?} to {max_version:?}")] #[platform_serialize(unversioned)] @@ -53,7 +65,7 @@ impl From for ConsensusError { #[cfg(test)] mod tests { use super::*; - use crate::serialization::PlatformDeserializable; + use crate::serialization::PlatformDeserializableUntrusted; use crate::serialization::PlatformSerializableWithPlatformVersion; use platform_version::version::LATEST_PLATFORM_VERSION; @@ -68,7 +80,8 @@ mod tests { .expect("expected to serialize"); let recovered_consensus_error = - ConsensusError::deserialize_from_bytes(&serialized_bytes).expect("should deserialize"); + ConsensusError::deserialize_from_bytes_untrusted(&serialized_bytes) + .expect("should deserialize"); assert_eq!(consensus_error, recovered_consensus_error); } diff --git a/packages/rs-dpp/src/errors/consensus/basic/value_error.rs b/packages/rs-dpp/src/errors/consensus/basic/value_error.rs index 83f1b85cdb5..35b9f37764f 100644 --- a/packages/rs-dpp/src/errors/consensus/basic/value_error.rs +++ b/packages/rs-dpp/src/errors/consensus/basic/value_error.rs @@ -1,13 +1,25 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Error as PlatformValueError; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{value_error}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/consensus_error.rs b/packages/rs-dpp/src/errors/consensus/consensus_error.rs index 008a8592b46..798ca5c41bb 100644 --- a/packages/rs-dpp/src/errors/consensus/consensus_error.rs +++ b/packages/rs-dpp/src/errors/consensus/consensus_error.rs @@ -1,7 +1,9 @@ use crate::errors::ProtocolError; use bincode; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use crate::consensus::state::state_error::StateError; @@ -21,9 +23,11 @@ use crate::errors::consensus::basic::BasicError; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, Clone, PartialEq, + DecodeUntrusted, )] #[platform_serialize(limit = 2000)] #[error(transparent)] diff --git a/packages/rs-dpp/src/errors/consensus/fee/balance_is_not_enough_error.rs b/packages/rs-dpp/src/errors/consensus/fee/balance_is_not_enough_error.rs index ceeb12ac2d0..1105032bf83 100644 --- a/packages/rs-dpp/src/errors/consensus/fee/balance_is_not_enough_error.rs +++ b/packages/rs-dpp/src/errors/consensus/fee/balance_is_not_enough_error.rs @@ -4,12 +4,24 @@ use crate::fee::Credits; use thiserror::Error; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Current credits balance {balance} is not enough to pay {fee} fee")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/fee/fee_error.rs b/packages/rs-dpp/src/errors/consensus/fee/fee_error.rs index cc19ca60f2f..24d9ca7ed1b 100644 --- a/packages/rs-dpp/src/errors/consensus/fee/fee_error.rs +++ b/packages/rs-dpp/src/errors/consensus/fee/fee_error.rs @@ -1,13 +1,24 @@ use crate::errors::consensus::fee::balance_is_not_enough_error::BalanceIsNotEnoughError; use crate::errors::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use thiserror::Error; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[derive( - Error, Debug, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone, + Error, + Debug, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Clone, + DecodeUntrusted, )] pub enum FeeError { /* diff --git a/packages/rs-dpp/src/errors/consensus/signature/basic_bls_error.rs b/packages/rs-dpp/src/errors/consensus/signature/basic_bls_error.rs index dead2aff6dc..108afecc1b7 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/basic_bls_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/basic_bls_error.rs @@ -1,10 +1,12 @@ use crate::consensus::signature::signature_error::SignatureError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("bls signing error {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/basic_ecdsa_error.rs b/packages/rs-dpp/src/errors/consensus/signature/basic_ecdsa_error.rs index eb1ea64348e..7f62d238186 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/basic_ecdsa_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/basic_ecdsa_error.rs @@ -1,10 +1,12 @@ use crate::consensus::signature::signature_error::SignatureError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("ecdsa signing error {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs index daf90820bdd..d54b3243c5c 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/identity_not_found_error.rs @@ -5,12 +5,24 @@ use crate::consensus::ConsensusError; use crate::prelude::Identifier; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity {identity_id} not found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs b/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs index b5b8365e731..05fdc0ccba7 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/invalid_identity_public_key_type_error.rs @@ -5,12 +5,24 @@ use crate::consensus::ConsensusError; use crate::identity::KeyType; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Unsupported signature type {public_key_type}. Please use ECDSA (0), BLS (1) or ECDSA_HASH160 (2) keys to sign the state transition")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_purpose_error.rs b/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_purpose_error.rs index 1477f7b1d9d..ce33afc2a24 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_purpose_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_purpose_error.rs @@ -5,13 +5,25 @@ use crate::consensus::ConsensusError; use crate::identity::Purpose; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use itertools::Itertools; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid public key purpose {public_key_purpose}. The state transition requires {}", allowed_key_purposes.iter().map(|s| s.to_string()).join(" | "))] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs b/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs index cb295903a38..408fe3456e1 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/invalid_signature_public_key_security_level_error.rs @@ -6,12 +6,24 @@ use crate::consensus::ConsensusError; use crate::identity::SecurityLevel; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid public key security level {public_key_security_level}. The state transition requires one of {}", allowed_key_security_levels.iter().map(|s| s.to_string()).join(" | "))] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/invalid_state_transition_signature_error.rs b/packages/rs-dpp/src/errors/consensus/signature/invalid_state_transition_signature_error.rs index 4c179a63f3d..3adea45b2b8 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/invalid_state_transition_signature_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/invalid_state_transition_signature_error.rs @@ -1,8 +1,10 @@ use crate::consensus::signature::signature_error::SignatureError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( @@ -15,7 +17,9 @@ use thiserror::Error; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid State Transition signature")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs b/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs index 10775e1ea69..4f404989ca3 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/missing_public_key_error.rs @@ -5,12 +5,24 @@ use crate::consensus::ConsensusError; use crate::identity::KeyID; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Public key {public_key_id} doesn't exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs b/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs index 16408ff1586..267ebfdad91 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/public_key_is_disabled_error.rs @@ -4,12 +4,24 @@ use crate::consensus::signature::signature_error::SignatureError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity key {public_key_id} is disabled")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs b/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs index 96382271ef8..50de65dba64 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/public_key_security_level_not_met_error.rs @@ -5,12 +5,24 @@ use crate::consensus::ConsensusError; use crate::identity::SecurityLevel; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid security level {public_key_security_level}. This state transition requires at least {required_security_level}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/signature_error.rs b/packages/rs-dpp/src/errors/consensus/signature/signature_error.rs index 72b0e7afb1a..c149c3ef121 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/signature_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/signature_error.rs @@ -6,15 +6,26 @@ use crate::consensus::signature::{ WrongPublicKeyPurposeError, }; use crate::consensus::ConsensusError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use thiserror::Error; use crate::consensus::signature::invalid_signature_public_key_purpose_error::InvalidSignaturePublicKeyPurposeError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[derive( - Error, Debug, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone, + Error, + Debug, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Clone, + DecodeUntrusted, )] pub enum SignatureError { /* diff --git a/packages/rs-dpp/src/errors/consensus/signature/signature_should_not_be_present_error.rs b/packages/rs-dpp/src/errors/consensus/signature/signature_should_not_be_present_error.rs index f96c9d05a84..7870157d4b2 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/signature_should_not_be_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/signature_should_not_be_present_error.rs @@ -1,10 +1,12 @@ use crate::consensus::signature::signature_error::SignatureError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("signature should be empty {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/uncompressed_public_key_not_allowed_error.rs b/packages/rs-dpp/src/errors/consensus/signature/uncompressed_public_key_not_allowed_error.rs index f4e5434a65d..08d4379afd5 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/uncompressed_public_key_not_allowed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/uncompressed_public_key_not_allowed_error.rs @@ -1,12 +1,24 @@ use crate::consensus::signature::signature_error::SignatureError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Uncompressed public keys are not allowed: expected 33 bytes (compressed), got {public_key_size} bytes")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs b/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs index 4ea2b0c246c..1678625258d 100644 --- a/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs +++ b/packages/rs-dpp/src/errors/consensus/signature/wrong_public_key_purpose_error.rs @@ -5,13 +5,25 @@ use crate::consensus::ConsensusError; use crate::identity::Purpose; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use itertools::Itertools; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid identity key purpose {public_key_purpose}. This state transition requires {}", allowed_key_purposes.iter().map(|s| s.to_string()).join(" | "))] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/address_funds/address_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/address_funds/address_does_not_exist_error.rs index 8e798206fe7..184b6c6983e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/address_funds/address_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/address_funds/address_does_not_exist_error.rs @@ -2,12 +2,24 @@ use crate::address_funds::PlatformAddress; use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error("Address does not exist: {address}")] diff --git a/packages/rs-dpp/src/errors/consensus/state/address_funds/address_invalid_nonce_error.rs b/packages/rs-dpp/src/errors/consensus/state/address_funds/address_invalid_nonce_error.rs index bb6eedbbac6..f1e48390f55 100644 --- a/packages/rs-dpp/src/errors/consensus/state/address_funds/address_invalid_nonce_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/address_funds/address_invalid_nonce_error.rs @@ -3,12 +3,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::prelude::AddressNonce; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Invalid address nonce for {address}: expected {expected_nonce}, got {provided_nonce}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/address_funds/address_not_enough_funds_error.rs b/packages/rs-dpp/src/errors/consensus/state/address_funds/address_not_enough_funds_error.rs index 7d49d154eb1..9a0b93c3705 100644 --- a/packages/rs-dpp/src/errors/consensus/state/address_funds/address_not_enough_funds_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/address_funds/address_not_enough_funds_error.rs @@ -3,12 +3,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::fee::Credits; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Insufficient address balance for {address}: has {balance}, requires at least {required_balance}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/address_funds/addresses_not_enough_funds_error.rs b/packages/rs-dpp/src/errors/consensus/state/address_funds/addresses_not_enough_funds_error.rs index 10b2501db61..dc7c5ed8336 100644 --- a/packages/rs-dpp/src/errors/consensus/state/address_funds/addresses_not_enough_funds_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/address_funds/addresses_not_enough_funds_error.rs @@ -4,13 +4,25 @@ use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::fee::Credits; use crate::prelude::AddressNonce; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use std::collections::BTreeMap; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Insufficient combined address balances: total available is less than required {required_balance}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_already_present_error.rs index a24ee194136..2826f21adae 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_already_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_already_present_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data Contract {data_contract_id} is already present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_config_update_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_config_update_error.rs index 19ad1b90754..cbc1933caf1 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_config_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_config_update_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Can't update Data Contract {data_contract_id} config: {additional_message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_is_readonly_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_is_readonly_error.rs index fded770a5fc..c51e348704b 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_is_readonly_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_is_readonly_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Can't update document schemas in the Data Contract {data_contract_id}: Data Contract is readonly")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_not_found_error.rs index 1f11adbf086..415149dbb1f 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_not_found_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error("Data contract not found for id: {data_contract_id}")] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_action_not_allowed_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_action_not_allowed_error.rs index 0064bc5923a..c3e65677be4 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_action_not_allowed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_action_not_allowed_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Action '{action}' is not allowed on Data Contract {data_contract_id}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_permission_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_permission_error.rs index 73cafe6de32..88068281600 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_permission_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/data_contract_update_permission_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {identity_id} doesn't have permissions to update Data Contract {data_contract_id}" diff --git a/packages/rs-dpp/src/errors/consensus/state/data_contract/document_type_update_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_contract/document_type_update_error.rs index a18c21f0c71..be31b612045 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_contract/document_type_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_contract/document_type_update_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Can't update Document Type {data_contract_id}::{document_type_name}: {additional_message}" diff --git a/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_condition_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_condition_error.rs index 9f0c216588e..8438d0ce595 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_condition_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_condition_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; use crate::consensus::state::data_trigger::DataTriggerError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_execution_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_execution_error.rs index f8bc1b46cf2..70f701f9782 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_execution_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_execution_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; use crate::consensus::state::data_trigger::DataTriggerError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_invalid_result_error.rs b/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_invalid_result_error.rs index 35f06d3ff93..b69693c0597 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_invalid_result_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_trigger/data_trigger_invalid_result_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; use crate::consensus::state::data_trigger::DataTriggerError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Data trigger have not returned any result")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/data_trigger/mod.rs b/packages/rs-dpp/src/errors/consensus/state/data_trigger/mod.rs index e43de444588..f192ba68f0c 100644 --- a/packages/rs-dpp/src/errors/consensus/state/data_trigger/mod.rs +++ b/packages/rs-dpp/src/errors/consensus/state/data_trigger/mod.rs @@ -4,8 +4,10 @@ use crate::consensus::state::data_trigger::data_trigger_invalid_result_error::Da use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; pub mod data_trigger_condition_error; @@ -13,7 +15,16 @@ pub mod data_trigger_execution_error; pub mod data_trigger_invalid_result_error; #[derive( - Error, Debug, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone, + Error, + Debug, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Clone, + DecodeUntrusted, )] pub enum DataTriggerError { /* diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_already_present_error.rs index 05a91fd4e4c..ba4d433f6c8 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_already_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_already_present_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} is already present")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_currently_locked_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_currently_locked_error.rs index 289d21a357a..71427205d18 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_currently_locked_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_currently_locked_error.rs @@ -3,12 +3,23 @@ use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::voting::vote_info_storage::contested_document_vote_poll_stored_info::ContestedDocumentVotePollStoredInfo; use crate::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document Contest for vote_poll {vote_poll} is currently already locked {stored_info}, unlocking is possible by paying {unlock_cost} credits")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_document_with_same_id_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_document_with_same_id_already_present_error.rs index 7ddd37b52f3..981cb5df2ab 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_document_with_same_id_already_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_document_with_same_id_already_present_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} is already present in a contest, entropy might be being reused")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_identity_already_contestant.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_identity_already_contestant.rs index 1f2cf0a14dc..17c6370e3bb 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_identity_already_contestant.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_identity_already_contestant.rs @@ -2,13 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "An Identity with the id {identity_id} is already a contestant for the vote_poll {vote_poll}" diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_index_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_index_mismatch_error.rs index 87861b5bf1b..51b5ea065f5 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_index_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_index_mismatch_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Contest for document {document_id} prefunded the voting balance of index {provided_index_name}, but the contested index resolved for this document is {expected_index_name}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_joinable_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_joinable_error.rs index 01abd52d675..8035030a5b8 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_joinable_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_joinable_error.rs @@ -4,12 +4,23 @@ use crate::errors::ProtocolError; use crate::prelude::TimestampMillis; use crate::voting::vote_info_storage::contested_document_vote_poll_stored_info::ContestedDocumentVotePollStoredInfo; use crate::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document Contest for vote_poll {vote_poll} is not joinable {stored_info}, it started {start_time} and it is now {current_time}, and you can only join for {joinable_time}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_paid_for_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_paid_for_error.rs index 9e6138c7a5d..69c1a34510d 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_paid_for_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_paid_for_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::fee::Credits; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Contest for document {document_id} was not paid for, needs payment of {expected_amount} Credits")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_required_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_required_error.rs index bb5346b58e0..e791b851fe8 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_required_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_contest_not_required_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} prefunded the voting balance of index {provided_index_name}, but this document does not resolve to a contested index")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_incorrect_purchase_price_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_incorrect_purchase_price_error.rs index 5e726c5cbef..fdab232a932 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_incorrect_purchase_price_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_incorrect_purchase_price_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::fee::Credits; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{document_id} document can not be purchased for {trying_to_purchase_at_price}, it's sale price is {actual_price} (in credits)")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_not_for_sale_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_not_for_sale_error.rs index 1304477355f..b224df5bbe9 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_not_for_sale_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_not_for_sale_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{document_id} document not for sale")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_not_found_error.rs index 81f284a70c6..3ded5be80ea 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_not_found_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{document_id} document not found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_owner_id_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_owner_id_mismatch_error.rs index ee71485e4c5..9461832c7e0 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_owner_id_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_owner_id_mismatch_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Provided document {document_id} owner ID {document_owner_id} mismatch with existing {existing_document_owner_id}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_timestamp_window_violation_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_timestamp_window_violation_error.rs index 174bc1243d6..88489dcb457 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_timestamp_window_violation_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_timestamp_window_violation_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} {timestamp_name} timestamp {timestamp} are out of block time window from {time_window_start} and {time_window_end}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs index 5ee92b503a6..451f154f3d7 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} createdAt and updatedAt should not be equal")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_mismatch_error.rs index 5ccf950b2b5..0b6277f78fb 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/document_timestamps_mismatch_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} createdAt and updatedAt timestamps are not equal")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/duplicate_unique_index_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/duplicate_unique_index_error.rs index 60b704b4b2b..1b1d49db38a 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/duplicate_unique_index_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/duplicate_unique_index_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Document {document_id} has duplicate unique properties {duplicating_properties:?} with other documents")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/invalid_document_revision_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/invalid_document_revision_error.rs index ea88528c893..798ff4858f2 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/invalid_document_revision_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/invalid_document_revision_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::prelude::Revision; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Document {document_id} has invalid revision {previous_revision:?}. The desired revision is {desired_revision}" diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_agreement_invalid_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_agreement_invalid_error.rs index 775e1932554..a8ec15e47a8 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_agreement_invalid_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_agreement_invalid_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("invalid propertyAgreement pair {referring_property} -> {referenced_property} declared at {path}: {reason}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_mismatch_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_mismatch_error.rs index 2a5f1fae601..f369c976162 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_mismatch_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_property_mismatch_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("the document's {referring_property} does not agree with the referenced document's {referenced_property} (propertyAgreement on {path})")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_deletable_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_deletable_error.rs index c8a300dbb60..78685131f92 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_deletable_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_deletable_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("documents of referenced document type {document_type_name} in contract {contract_id} can be deleted; a permanentDocument reference at path {path} requires a document type with canBeDeleted: false")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_not_found_error.rs index 0981f9ebc3c..329c61aec68 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_document_type_not_found_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("referenced document type {document_type_name} not found in contract {contract_id} for path {path}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_entity_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_entity_not_found_error.rs index 7628c155ae9..3e8d5de36b6 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_entity_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_entity_not_found_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::document_type::DocumentPropertyReferenceTarget; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("referenced {entity_type} {entity_id} not found for path {path}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_disabled_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_disabled_error.rs index e006c18f7ac..5c46b2038f4 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_disabled_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_disabled_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::identity::KeyID; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("referenced public key {key_id} of identity {identity_id} is disabled for path {path}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_not_found_error.rs index 95726dc4493..6139e95933b 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_identity_key_not_found_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::identity::KeyID; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("referenced public key {key_id} of identity {identity_id} not found for path {path}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/document/referenced_key_id_property_invalid_error.rs b/packages/rs-dpp/src/errors/consensus/state/document/referenced_key_id_property_invalid_error.rs index 3ea50009562..fb71c01725f 100644 --- a/packages/rs-dpp/src/errors/consensus/state/document/referenced_key_id_property_invalid_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/document/referenced_key_id_property_invalid_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("keyIdProperty {key_id_property} referenced at path {path} is invalid: {message}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_completed_error.rs b/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_completed_error.rs index 2d700d72a3f..cda4b2b9994 100644 --- a/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_completed_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_completed_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Group action has already been completed for data contract {} at group position {} with action ID {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_signed_by_identity_error.rs b/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_signed_by_identity_error.rs index 1fcdbf0419c..7c9ac4f7748 100644 --- a/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_signed_by_identity_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/group/group_action_already_signed_by_identity_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Group action with action ID {} has already been signed by identity {} for data contract {} at group position {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/group/group_action_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/group/group_action_does_not_exist_error.rs index c57af3cc4d2..42556a541bd 100644 --- a/packages/rs-dpp/src/errors/consensus/state/group/group_action_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/group/group_action_does_not_exist_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Group action does not exist for data contract {} at group position {} with action ID {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/group/identity_for_group_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/group/identity_for_group_not_found_error.rs index bbede322c3b..08a84eb5948 100644 --- a/packages/rs-dpp/src/errors/consensus/state/group/identity_for_group_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/group/identity_for_group_not_found_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("identity {member_id} was not found in group at position {group_position} in contract {contract_id}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/group/identity_not_member_of_group_error.rs b/packages/rs-dpp/src/errors/consensus/state/group/identity_not_member_of_group_error.rs index afd5bf06ffb..c146a901d3a 100644 --- a/packages/rs-dpp/src/errors/consensus/state/group/identity_not_member_of_group_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/group/identity_not_member_of_group_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {} is not a member of the group for data contract {} at position {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/group/modification_of_group_action_main_parameters_not_permitted_error.rs b/packages/rs-dpp/src/errors/consensus/state/group/modification_of_group_action_main_parameters_not_permitted_error.rs index ff710ddb376..89f6ae95891 100644 --- a/packages/rs-dpp/src/errors/consensus/state/group/modification_of_group_action_main_parameters_not_permitted_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/group/modification_of_group_action_main_parameters_not_permitted_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Modification of group action main parameters is not permitted.\n\ diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs index a4903455884..3ca632dfd4a 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Duplicated public keys ids {duplicated_ids:?} found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_state_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_state_error.rs index f8631cb2e86..b4f98510eb5 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_state_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/duplicated_identity_public_key_state_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Duplicated public keys {duplicated_public_key_ids:?} found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_already_exists_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_already_exists_error.rs index b07f91df7a2..3bbe279acda 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_already_exists_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_already_exists_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity {identity_id:?} already exists")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_for_token_configuration_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_for_token_configuration_not_found_error.rs index 374a33f56b8..72c7be22cdf 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_for_token_configuration_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_for_token_configuration_not_found_error.rs @@ -1,12 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; -#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize)] +#[derive( + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, +)] #[platform_serialize(unversioned)] pub enum TokenConfigurationIdentityContext { ChangeControlRule(String), @@ -16,7 +29,17 @@ pub enum TokenConfigurationIdentityContext { } #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity {identity_id} required in token position {token_position} of contract {contract_id} for {context:?} does not exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_insufficient_balance_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_insufficient_balance_error.rs index 0d308f7981a..45110a93c1e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_insufficient_balance_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_insufficient_balance_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::prelude::Identifier; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Insufficient identity {identity_id} balance {balance} required {required_balance}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_already_exists_for_unique_contract_bounds_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_already_exists_for_unique_contract_bounds_error.rs index ec206efcac6..a5dec7f966b 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_already_exists_for_unique_contract_bounds_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_already_exists_for_unique_contract_bounds_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::{KeyID, Purpose}; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Public Key with id {new_key_id} for identity {identity_id:?} conflicts for purpose {purpose} with key {old_key_id} in the contract bounds of {contract_id:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_disabled_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_disabled_error.rs index efbaff0629d..02bbdec27da 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_disabled_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_disabled_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Public Key #{public_key_index} is disabled")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_read_only_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_read_only_error.rs index d60d5250b0e..a1e7152e0aa 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_read_only_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_public_key_is_read_only_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Public Key #{public_key_index} is read only")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/identity_to_freeze_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/identity_to_freeze_does_not_exist_error.rs index 6e5f1d9aedd..8fe2563fa41 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/identity_to_freeze_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/identity_to_freeze_does_not_exist_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity to freeze {} does not exist", identity_to_freeze_id)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_contract_nonce_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_contract_nonce_error.rs index 39bbbfaaaf5..ed80ca87758 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_contract_nonce_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_contract_nonce_error.rs @@ -1,17 +1,29 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; -use crate::ProtocolError; // needed for PlatformDeserialize and PlatformSerialize -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use crate::ProtocolError; // needed for PlatformDeserializeTrusted, PlatformDeserializeUntrusted and PlatformSerialize +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use std::fmt::{Display, Formatter}; use thiserror::Error; use crate::prelude::{Identifier, IdentityNonce}; use crate::identity::identity_nonce::MergeIdentityNonceResult; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] pub struct InvalidIdentityNonceError { diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_public_key_id_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_public_key_id_error.rs index 8e6171579bf..a906750f19e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_public_key_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_public_key_id_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Public Key with Id {id} does not exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_revision_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_revision_error.rs index 1deb1de9aca..b36546747fd 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_revision_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/invalid_identity_revision_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::prelude::{Identifier, Revision}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity {identity_id} has invalid revision. The current revision is {current_revision}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/master_public_key_update_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/master_public_key_update_error.rs index bde78547a79..d1f201fb8d9 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/master_public_key_update_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/master_public_key_update_error.rs @@ -1,10 +1,12 @@ use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( Error, @@ -16,7 +18,9 @@ use bincode::{Decode, Encode}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Failed to update the master public key: {description}. Ensure the operation is valid and permissible under current system rules.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/max_identity_public_key_limit_reached_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/max_identity_public_key_limit_reached_error.rs index f33d5b32c93..1699d3cde6e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/max_identity_public_key_limit_reached_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/max_identity_public_key_limit_reached_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity cannot contain more than {max_items} public keys")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/missing_identity_public_key_ids_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/missing_identity_public_key_ids_error.rs index 25ac3bd2763..d86dfdd121c 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/missing_identity_public_key_ids_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/missing_identity_public_key_ids_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::identity::KeyID; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity Public Key with Ids {} do not exist", ids.iter().map(|id| id.to_string()).collect::>().join(", "))] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/missing_transfer_key_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/missing_transfer_key_error.rs index 2f14ccacbce..8612ac856f9 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/missing_transfer_key_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/missing_transfer_key_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Identity {identity_id} does not have a key for transferring funds")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/no_transfer_key_for_core_withdrawal_available_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/no_transfer_key_for_core_withdrawal_available_error.rs index 77f5d52305a..43e382326a3 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/no_transfer_key_for_core_withdrawal_available_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/no_transfer_key_for_core_withdrawal_available_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("There is no transfer key that can be used for a withdrawal")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/identity/recipient_identity_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/identity/recipient_identity_does_not_exist_error.rs index dc6a838f76f..7e42b12d6e6 100644 --- a/packages/rs-dpp/src/errors/consensus/state/identity/recipient_identity_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/identity/recipient_identity_does_not_exist_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Recipient identity {} does not exist", recipient_id)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_insufficient_error.rs b/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_insufficient_error.rs index 05bbb113249..7f05aa378f3 100644 --- a/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_insufficient_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_insufficient_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::prelude::Identifier; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Insufficient specialized balance {balance_id} balance {balance} required {required_balance}" diff --git a/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_not_found_error.rs index bf8f4bc1002..62785e1a7be 100644 --- a/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/prefunded_specialized_balances/prefunded_specialized_balance_not_found_error.rs @@ -1,15 +1,27 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::prelude::Identifier; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Did not find a specialized balance with id: {balance_id}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_pool_notes_error.rs b/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_pool_notes_error.rs index 3358017ab95..7b6d452a981 100644 --- a/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_pool_notes_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_pool_notes_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error( diff --git a/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_shielded_fee_error.rs b/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_shielded_fee_error.rs index 4bfcd288404..6c6e3bc5e2c 100644 --- a/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_shielded_fee_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/shielded/insufficient_shielded_fee_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error("Insufficient shielded transaction fee: {message}")] diff --git a/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_anchor_error.rs b/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_anchor_error.rs index f0839902d57..8763f6a267e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_anchor_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_anchor_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error( diff --git a/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_shielded_proof_error.rs b/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_shielded_proof_error.rs index b18b8c30f58..c3a9293b91e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_shielded_proof_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/shielded/invalid_shielded_proof_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error("Invalid shielded transaction proof: {message}")] diff --git a/packages/rs-dpp/src/errors/consensus/state/shielded/nullifier_already_spent_error.rs b/packages/rs-dpp/src/errors/consensus/state/shielded/nullifier_already_spent_error.rs index a82430c6d0f..b26c29a5f93 100644 --- a/packages/rs-dpp/src/errors/consensus/state/shielded/nullifier_already_spent_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/shielded/nullifier_already_spent_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] #[error("Nullifier has already been spent: {}", hex::encode(nullifier))] diff --git a/packages/rs-dpp/src/errors/consensus/state/state_error.rs b/packages/rs-dpp/src/errors/consensus/state/state_error.rs index b9ad50cdaf1..34f8e6a3db5 100644 --- a/packages/rs-dpp/src/errors/consensus/state/state_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/state_error.rs @@ -1,6 +1,8 @@ use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; use crate::consensus::state::address_funds::{AddressDoesNotExistError, AddressInvalidNonceError, AddressNotEnoughFundsError, AddressesNotEnoughFundsError}; @@ -72,7 +74,16 @@ use crate::consensus::state::voting::vote_poll_not_found_error::VotePollNotFound use super::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError; #[derive( - Error, Debug, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, Clone, + Error, + Debug, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + Clone, + DecodeUntrusted, )] pub enum StateError { /* diff --git a/packages/rs-dpp/src/errors/consensus/state/token/identity_does_not_have_enough_token_balance_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/identity_does_not_have_enough_token_balance_error.rs index ba1c5b7fd61..f966edced94 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/identity_does_not_have_enough_token_balance_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/identity_does_not_have_enough_token_balance_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {} does not have enough balance for token {}: required {}, actual {}, action: {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/identity_has_not_agreed_to_pay_required_token_amount_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/identity_has_not_agreed_to_pay_required_token_amount_error.rs index 1096cbf929e..c672da11146 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/identity_has_not_agreed_to_pay_required_token_amount_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/identity_has_not_agreed_to_pay_required_token_amount_error.rs @@ -2,13 +2,25 @@ use crate::balances::credits::TokenAmount; use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity has not agreed to pay the required token amount for token {}: required {}, min offer {:?}, max offer {:?}, action: {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_already_frozen_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_already_frozen_error.rs index c894e465b70..ce4560b3fed 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_already_frozen_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_already_frozen_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {} account is already frozen for token {}. Action attempted: {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_frozen_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_frozen_error.rs index 6d4a55e6092..4423714730c 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_frozen_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_frozen_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {} account is frozen for token {}. Action attempted: {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_not_frozen_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_not_frozen_error.rs index 479fcc1a500..08eee5bc4a1 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_not_frozen_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/identity_token_account_not_frozen_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {} account is not frozen for token {}. Action attempted: {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/identity_trying_to_pay_with_wrong_token_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/identity_trying_to_pay_with_wrong_token_error.rs index 89e2e730562..9fc99ee0928 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/identity_trying_to_pay_with_wrong_token_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/identity_trying_to_pay_with_wrong_token_error.rs @@ -2,11 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; -#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize)] +#[derive( + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, +)] #[platform_serialize(unversioned)] pub struct IdentityTryingToPayWithWrongTokenError { expected_contract_id: Option, diff --git a/packages/rs-dpp/src/errors/consensus/state/token/invalid_group_position_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/invalid_group_position_error.rs index e93459d0365..4af1cf10880 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/invalid_group_position_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/invalid_group_position_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid group position: {invalid_group_position}. {max_group_message}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_no_current_rewards.rs b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_no_current_rewards.rs index 19e133903c0..906595020a7 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_no_current_rewards.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_no_current_rewards.rs @@ -3,12 +3,22 @@ use crate::data_contract::associated_token::token_perpetual_distribution::reward use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, Encode, DecodeUntrusted}; +use platform_serialization_derive::{PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "No current rewards available for recipient '{}' on token ID '{}' at moment '{}'. Last claimed moment: '{}'", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_property_mismatch.rs b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_property_mismatch.rs index f6261f1e549..9c3e13b58d3 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_property_mismatch.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_property_mismatch.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::prelude::Identifier; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token release property mismatch for '{}', token ID: {}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_wrong_claimant.rs b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_wrong_claimant.rs index 57e48ed141d..fd5f456a78a 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_wrong_claimant.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_claim_wrong_claimant.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::prelude::Identifier; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Token claim error: Identity '{}' is not a valid claimant for this distribution type of token '{}'. The valid claimaint is '{}'.", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_position_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_position_error.rs index faac2df3c1c..52137c57a26 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_position_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/invalid_token_position_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Invalid token position: {invalid_token_position}. {max_token_message}", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_group_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_group_does_not_exist_error.rs index 2ea523ddbbf..de29f8b91b7 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_group_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_group_does_not_exist_error.rs @@ -2,12 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::GroupContractPosition; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("The specified new authorized action taker group {group_contract_position} does not exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_identity_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_identity_does_not_exist_error.rs index 9f02bc0117c..ed0eeebc575 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_identity_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_identity_does_not_exist_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("The specified new authorized action taker identity {identity_id} does not exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_main_group_not_set_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_main_group_not_set_error.rs index db4e45c0af3..35052d7fa83 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_main_group_not_set_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/new_authorized_action_taker_main_group_not_set_error.rs @@ -1,12 +1,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "The specified new authorized action taker main group is not set in the token configuration" diff --git a/packages/rs-dpp/src/errors/consensus/state/token/new_tokens_destination_identity_does_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/new_tokens_destination_identity_does_not_exist_error.rs index ae18548891a..f3e589481ba 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/new_tokens_destination_identity_does_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/new_tokens_destination_identity_does_not_exist_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("The specified new tokens destination identity {identity_id} does not exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/pre_programmed_distribution_timestamp_in_past_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/pre_programmed_distribution_timestamp_in_past_error.rs index 9b13ea8df43..63b9b8ee8a2 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/pre_programmed_distribution_timestamp_in_past_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/pre_programmed_distribution_timestamp_in_past_error.rs @@ -3,13 +3,25 @@ use crate::consensus::ConsensusError; use crate::data_contract::TokenContractPosition; use crate::identity::TimestampMillis; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Pre-programmed token distribution time {pre_programmed_timestamp}ms is in the past for token {token_position} in data contract {data_contract_id}. Current block time is {current_timestamp}.", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/required_token_payment_info_not_set_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/required_token_payment_info_not_set_error.rs index f1a76fe8ab1..f2632e1cde6 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/required_token_payment_info_not_set_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/required_token_payment_info_not_set_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Required token payment info not set on token {} (action: {})", diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_already_paused_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_already_paused_error.rs index 4560e3fc4de..040afc52e74 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_already_paused_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_already_paused_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token {} is already paused. Action attempted: {}", token_id, action)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_amount_under_minimum_sale_amount.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_amount_under_minimum_sale_amount.rs index 921050fff49..d196110e7ad 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_amount_under_minimum_sale_amount.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_amount_under_minimum_sale_amount.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Requested token amount {desired_amount} is below the minimum sale amount {minimum_amount} for token {token_id}." diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_direct_purchase_user_price_too_low.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_direct_purchase_user_price_too_low.rs index 4824eeb5b9a..9e4e52e97aa 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_direct_purchase_user_price_too_low.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_direct_purchase_user_price_too_low.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::fee::Credits; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Provided direct purchase price {user_price} is below the required price {required_price} for token {token_id}." diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_is_paused_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_is_paused_error.rs index 5681940847f..90eee887798 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_is_paused_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_is_paused_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token {} is paused.", token_id)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_mint_past_max_supply_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_mint_past_max_supply_error.rs index c97a2d0830e..2d736bc0a9f 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_mint_past_max_supply_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_mint_past_max_supply_error.rs @@ -2,13 +2,25 @@ use crate::balances::credits::TokenAmount; use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Token {token_id} attempted to mint {amount}, which exceeds the max supply {max_supply}, current supply is {current_supply}" diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_not_for_direct_sale.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_not_for_direct_sale.rs index 7eb0921798b..5d4955fa4c2 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_not_for_direct_sale.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_not_for_direct_sale.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token {token_id} is not available for direct sale.")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_not_paused_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_not_paused_error.rs index 63cf71d4f10..5b8f29f884a 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_not_paused_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_not_paused_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token {} is not paused. Action attempted: {}", token_id, action)] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_setting_max_supply_to_less_than_current_supply_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_setting_max_supply_to_less_than_current_supply_error.rs index 511263c695f..7bc3d2ce595 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_setting_max_supply_to_less_than_current_supply_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_setting_max_supply_to_less_than_current_supply_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Token {token_id} attempted to set max supply to {max_supply}, which is less than the current supply {current_supply}" diff --git a/packages/rs-dpp/src/errors/consensus/state/token/token_transfer_recipient_identity_not_exist_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/token_transfer_recipient_identity_not_exist_error.rs index d88d5695b6f..c1818c56fdd 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/token_transfer_recipient_identity_not_exist_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/token_transfer_recipient_identity_not_exist_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Token transfer recipient identity {recipient_id} doesn't exist")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/token/unauthorized_token_action_error.rs b/packages/rs-dpp/src/errors/consensus/state/token/unauthorized_token_action_error.rs index 7245fee861b..d76f318226e 100644 --- a/packages/rs-dpp/src/errors/consensus/state/token/unauthorized_token_action_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/token/unauthorized_token_action_error.rs @@ -2,13 +2,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::data_contract::change_control_rules::authorized_action_takers::AuthorizedActionTakers; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error( "Identity {identity_id} is not authorized to perform action: {action} on token: {token_id}. Authorized action takers: {authorized_action_takers:?}", diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voter_identity_id_error.rs b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voter_identity_id_error.rs index 4219e0df96c..ba01179687c 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voter_identity_id_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voter_identity_id_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Masternode {pro_tx_hash} voter identity id is incorrect, expected is {expected_voter_identity_id}, provided is {provided_voter_identity_id}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voting_address_error.rs b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voting_address_error.rs index 5953eb86d39..0e2a55241ce 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voting_address_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_incorrect_voting_address_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::{Bytes20, Identifier}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Masternode {pro_tx_hash} voting address is incorrect, current is {current_voting_address}, given is {given_voting_address}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_not_found_error.rs index f004cfe79d4..ad00e6bbaa7 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_not_found_error.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Masternode {pro_tx_hash} not found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_vote_already_present_error.rs b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_vote_already_present_error.rs index 7526eba2172..fe84b587751 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_vote_already_present_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_vote_already_present_error.rs @@ -2,13 +2,24 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::voting::vote_polls::VotePoll; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Masternode vote is already present for masternode {pro_tx_hash} voting for {vote_poll}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_voted_too_many_times.rs b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_voted_too_many_times.rs index d1b167320a2..76542d6f073 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/masternode_voted_too_many_times.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/masternode_voted_too_many_times.rs @@ -1,13 +1,25 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("Masternode with id: {pro_tx_hash} already voted {times_already_voted} times and is trying to vote again, they can only vote {max_times_allowed} times")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_available_for_voting_error.rs b/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_available_for_voting_error.rs index 26341b31d4d..1be08ea6cfc 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_available_for_voting_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_available_for_voting_error.rs @@ -3,12 +3,23 @@ use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::voting::vote_info_storage::contested_document_vote_poll_stored_info::ContestedDocumentVotePollStatus; use crate::voting::vote_polls::VotePoll; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("VotePoll {vote_poll} not available for voting: {status}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_found_error.rs b/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_found_error.rs index 77a6c62bdde..4c78026053d 100644 --- a/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_found_error.rs +++ b/packages/rs-dpp/src/errors/consensus/state/voting/vote_poll_not_found_error.rs @@ -2,12 +2,23 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::errors::ProtocolError; use crate::voting::vote_polls::VotePoll; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("VotePoll {vote_poll} not found")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/errors/consensus/test_consensus_error.rs b/packages/rs-dpp/src/errors/consensus/test_consensus_error.rs index cfc240f21dc..320ac8d085f 100644 --- a/packages/rs-dpp/src/errors/consensus/test_consensus_error.rs +++ b/packages/rs-dpp/src/errors/consensus/test_consensus_error.rs @@ -1,10 +1,22 @@ use crate::errors::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use thiserror::Error; #[derive( - Error, Debug, Clone, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Error, + Debug, + Clone, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[error("{message:?}")] #[platform_serialize(unversioned)] diff --git a/packages/rs-dpp/src/fee/fee_result/refunds.rs b/packages/rs-dpp/src/fee/fee_result/refunds.rs index 65c453dab37..95142a4f82d 100644 --- a/packages/rs-dpp/src/fee/fee_result/refunds.rs +++ b/packages/rs-dpp/src/fee/fee_result/refunds.rs @@ -10,7 +10,7 @@ use crate::fee::epoch::distribution::calculate_storage_fee_refund_amount_and_lef use crate::fee::epoch::{BytesPerEpoch, CreditsPerEpoch}; use crate::fee::Credits; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; @@ -29,7 +29,9 @@ pub type CreditsPerEpochByIdentifier = BTreeMap<[u8; 32], CreditsPerEpoch>; pub type BytesPerEpochByIdentifier = BTreeMap<[u8; 32], BytesPerEpoch>; /// Fee refunds to identities based on removed data from specific epochs -#[derive(Debug, Clone, Eq, PartialEq, Default, Serialize, Deserialize, Encode, Decode)] +#[derive( + Debug, Clone, Eq, PartialEq, Default, Serialize, Deserialize, Encode, Decode, DecodeUntrusted, +)] pub struct FeeRefunds(pub CreditsPerEpochByIdentifier); impl FeeRefunds { diff --git a/packages/rs-dpp/src/group/action_event.rs b/packages/rs-dpp/src/group/action_event.rs index 24e7240142c..c6f821d0225 100644 --- a/packages/rs-dpp/src/group/action_event.rs +++ b/packages/rs-dpp/src/group/action_event.rs @@ -4,13 +4,25 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::tokens::token_event::TokenEvent; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; #[derive( - Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize, + Debug, + PartialEq, + PartialOrd, + Clone, + Eq, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/group/group_action/mod.rs b/packages/rs-dpp/src/group/group_action/mod.rs index d449f10cf32..4dbf87eefc6 100644 --- a/packages/rs-dpp/src/group/group_action/mod.rs +++ b/packages/rs-dpp/src/group/group_action/mod.rs @@ -8,8 +8,10 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -19,7 +21,17 @@ use serde::{Deserialize, Serialize}; derive(JsonConvertible) )] #[derive( - Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize, + Debug, + PartialEq, + PartialOrd, + Clone, + Eq, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -79,7 +91,7 @@ impl GroupActionAccessors for GroupAction { #[cfg(test)] mod deserialize_limit_tests { use super::*; - use crate::serialization::PlatformDeserializable; + use crate::serialization::PlatformDeserializableUntrusted; /// A proof element is untrusted input: a note length prefix must be /// rejected against the byte budget before it sizes an allocation. @@ -102,7 +114,7 @@ mod deserialize_limit_tests { // note length prefix claiming 8 GB, with no bytes following it buf.extend_from_slice(&bincode::encode_to_vec(8_000_000_000u64, config).unwrap()); - let err = GroupAction::deserialize_from_bytes(&buf) + let err = GroupAction::deserialize_from_bytes_untrusted(&buf) .expect_err("oversized length prefix must be rejected"); assert!( matches!(err, ProtocolError::MaxEncodedBytesReachedError { .. }), diff --git a/packages/rs-dpp/src/group/group_action/v0/mod.rs b/packages/rs-dpp/src/group/group_action/v0/mod.rs index 2daae2aba41..72113848b7c 100644 --- a/packages/rs-dpp/src/group/group_action/v0/mod.rs +++ b/packages/rs-dpp/src/group/group_action/v0/mod.rs @@ -4,15 +4,27 @@ use crate::group::group_action::GroupActionAccessors; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[derive( - Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize, + Debug, + PartialEq, + PartialOrd, + Clone, + Eq, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + DecodeUntrusted, )] #[cfg_attr(feature = "serde-conversion", derive(Serialize, Deserialize))] #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version diff --git a/packages/rs-dpp/src/group/mod.rs b/packages/rs-dpp/src/group/mod.rs index 1c033923c2d..6ca13ac8c23 100644 --- a/packages/rs-dpp/src/group/mod.rs +++ b/packages/rs-dpp/src/group/mod.rs @@ -2,7 +2,7 @@ use crate::data_contract::group::{Group, GroupMemberPower}; use crate::data_contract::GroupContractPosition; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] @@ -13,7 +13,7 @@ pub mod action_taker; pub mod group_action; pub mod group_action_status; -#[derive(Debug, Clone, Copy, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Copy, Encode, Decode, PartialEq, DecodeUntrusted)] pub enum GroupStateTransitionInfoStatus { GroupStateTransitionInfoProposer(GroupContractPosition), GroupStateTransitionInfoOtherSigner(GroupStateTransitionInfo), @@ -35,7 +35,7 @@ impl From for GroupStateTransitionInfo { } #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Copy, Encode, Decode, Default, PartialEq, Display)] +#[derive(Debug, Clone, Copy, Encode, Decode, Default, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/identity/core_script.rs b/packages/rs-dpp/src/identity/core_script.rs index e9cc9848c7e..57c0af37b8d 100644 --- a/packages/rs-dpp/src/identity/core_script.rs +++ b/packages/rs-dpp/src/identity/core_script.rs @@ -1,7 +1,7 @@ -use bincode::de::{BorrowDecoder, Decoder}; +use bincode::de::BorrowDecoder; use bincode::enc::Encoder; use bincode::error::{DecodeError, EncodeError}; -use bincode::{BorrowDecode, Decode, Encode}; +use bincode::{BorrowDecode, Encode}; use dashcore::blockdata::opcodes; use std::fmt; use std::ops::Deref; @@ -92,13 +92,23 @@ impl Encode for CoreScript { } // Implement the bincode::Decode trait for CoreScript -impl Decode for CoreScript { - fn decode>(decoder: &mut D) -> Result { - let bytes = Vec::::decode(decoder)?; - // Create a CoreScript instance using the decoded DashCoreScript - Ok(CoreScript(ScriptBuf(bytes))) - } +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_core_script_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for CoreScript { + fn $method>( + decoder: &mut D, + ) -> Result { + let bytes = Vec::::$method(decoder)?; + // Create a CoreScript instance using the decoded DashCoreScript + Ok(CoreScript(ScriptBuf(bytes))) + } + } + }; } +impl_core_script_decode!(Decode, Decoder, decode, false); +impl_core_script_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +bincode::impl_borrow_decode_untrusted!(CoreScript); impl<'de, C> BorrowDecode<'de, C> for CoreScript { fn borrow_decode>( diff --git a/packages/rs-dpp/src/identity/identity.rs b/packages/rs-dpp/src/identity/identity.rs index 86aee2c2d14..268eb3ca52f 100644 --- a/packages/rs-dpp/src/identity/identity.rs +++ b/packages/rs-dpp/src/identity/identity.rs @@ -17,10 +17,12 @@ use crate::version::PlatformVersion; use crate::ProtocolError; #[cfg(feature = "identity-serialization")] -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; #[cfg(feature = "identity-serialization")] -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use crate::fee::Credits; @@ -38,7 +40,14 @@ use std::collections::{BTreeMap, BTreeSet}; )] #[cfg_attr( feature = "identity-serialization", - derive(Encode, Decode, PlatformDeserialize, PlatformSerialize), + derive( + Encode, + Decode, + DecodeUntrusted, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize + ), platform_serialize(limit = 15000, unversioned) )] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] diff --git a/packages/rs-dpp/src/identity/identity_factory.rs b/packages/rs-dpp/src/identity/identity_factory.rs index b4795525e53..e5e0cd9dab8 100644 --- a/packages/rs-dpp/src/identity/identity_factory.rs +++ b/packages/rs-dpp/src/identity/identity_factory.rs @@ -28,7 +28,7 @@ use crate::identity::core_script::CoreScript; #[cfg(all(feature = "state-transitions", feature = "client"))] use crate::prelude::IdentityNonce; #[cfg(all(feature = "identity-serialization", feature = "client"))] -use crate::serialization::PlatformDeserializable; +use crate::serialization::PlatformDeserializableUntrusted; #[cfg(all(feature = "state-transitions", feature = "client"))] use crate::state_transition::identity_create_transition::v0::IdentityCreateTransitionV0; #[cfg(all(feature = "state-transitions", feature = "client"))] @@ -91,8 +91,8 @@ impl IdentityFactory { buffer: Vec, #[cfg(feature = "validation")] skip_validation: bool, ) -> Result { - let identity: Identity = - Identity::deserialize_from_bytes_no_limit(&buffer).map_err(|e| { + let identity: Identity = Identity::deserialize_from_bytes_untrusted_no_limit(&buffer) + .map_err(|e| { ConsensusError::BasicError(BasicError::SerializedObjectParsingError( SerializedObjectParsingError::new(format!("Decode protocol entity: {:#?}", e)), )) diff --git a/packages/rs-dpp/src/identity/identity_nonce.rs b/packages/rs-dpp/src/identity/identity_nonce.rs index 2e8ea96edb6..b79df7fef31 100644 --- a/packages/rs-dpp/src/identity/identity_nonce.rs +++ b/packages/rs-dpp/src/identity/identity_nonce.rs @@ -1,5 +1,7 @@ use crate::ProtocolError; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use std::fmt::{Debug, Display, Formatter}; use crate::consensus::state::identity::invalid_identity_contract_nonce_error::InvalidIdentityNonceError; @@ -7,7 +9,7 @@ use crate::consensus::state::state_error::StateError; use crate::consensus::ConsensusError; use crate::prelude::IdentityNonce; use crate::validation::SimpleConsensusValidationResult; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; pub const IDENTITY_NONCE_VALUE_FILTER: u64 = 0xFFFFFFFFFF; @@ -17,7 +19,17 @@ pub const MISSING_IDENTITY_REVISIONS_MAX_BYTES: u64 = MAX_MISSING_IDENTITY_REVIS pub const IDENTITY_NONCE_VALUE_FILTER_MAX_BYTES: u64 = 40; #[derive( - Debug, Clone, Copy, PartialEq, Eq, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Debug, + Clone, + Copy, + PartialEq, + Eq, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] /// The result of the merge of the identity contract nonce pub enum MergeIdentityNonceResult { diff --git a/packages/rs-dpp/src/identity/identity_public_key/contract_bounds/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/contract_bounds/mod.rs index 7052fea0813..898dbb7310d 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/contract_bounds/mod.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/contract_bounds/mod.rs @@ -7,7 +7,7 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; pub type ContractBoundsType = u8; @@ -21,7 +21,18 @@ pub type ContractBoundsType = u8; #[cfg_attr(feature = "json-conversion", derive(JsonConvertible))] #[repr(u8)] #[derive( - Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Encode, Decode, Ord, PartialOrd, Hash, + Debug, + PartialEq, + Eq, + Clone, + Serialize, + Deserialize, + Encode, + Decode, + Ord, + PartialOrd, + Hash, + DecodeUntrusted, )] #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] #[serde(tag = "$type", rename_all = "camelCase")] diff --git a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs index 3f5ddae640a..0914d245a04 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/key_type.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/key_type.rs @@ -1,6 +1,6 @@ use crate::util::hash::ripemd160_sha256; use anyhow::bail; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "cbor")] use ciborium::value::Value as CborValue; #[cfg(feature = "random-public-keys")] @@ -42,6 +42,7 @@ use std::convert::TryFrom; Decode, Default, strum::EnumIter, + DecodeUntrusted, )] pub enum KeyType { #[default] diff --git a/packages/rs-dpp/src/identity/identity_public_key/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/mod.rs index c76091ccddc..e0da5a2da20 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/mod.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/mod.rs @@ -6,7 +6,7 @@ use crate::identity::identity_public_key::v0::IdentityPublicKeyV0; use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use serde::{Deserialize, Serialize}; @@ -23,7 +23,9 @@ pub mod v0; use crate::version::PlatformVersion; use crate::ProtocolError; pub use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; pub mod methods; pub use methods::*; @@ -44,12 +46,14 @@ pub type TimestampMillis = u64; Deserialize, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, From, Hash, Ord, PartialOrd, + DecodeUntrusted, )] #[platform_serialize(limit = 2000, unversioned)] //This is not platform versioned automatically #[cfg_attr(feature = "value-conversion", derive(ValueConvertible))] @@ -214,7 +218,7 @@ mod tests { use crate::identity::identity_public_key::contract_bounds::ContractBounds; use crate::identity::identity_public_key::v0::IdentityPublicKeyV0; use crate::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel}; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use platform_value::{BinaryData, Identifier}; use platform_version::version::LATEST_PLATFORM_VERSION; use rand::SeedableRng; @@ -233,8 +237,10 @@ mod tests { .into(); let serialized = key.serialize_to_bytes().expect("expected to serialize key"); let unserialized: IdentityPublicKey = - PlatformDeserializable::deserialize_from_bytes(serialized.as_slice()) - .expect("expected to deserialize key"); + PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted( + serialized.as_slice(), + ) + .expect("expected to deserialize key"); assert_eq!(key, unserialized) } diff --git a/packages/rs-dpp/src/identity/identity_public_key/purpose.rs b/packages/rs-dpp/src/identity/identity_public_key/purpose.rs index 61cb212f096..18f0b6e20c0 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/purpose.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/purpose.rs @@ -2,7 +2,7 @@ use crate::identity::Purpose::{ AUTHENTICATION, DECRYPTION, ENCRYPTION, OWNER, SYSTEM, TRANSFER, VOTING, }; use anyhow::bail; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "cbor")] use ciborium::value::Value as CborValue; use serde_repr::{Deserialize_repr, Serialize_repr}; @@ -24,6 +24,7 @@ use std::convert::TryFrom; Decode, Default, strum::EnumIter, + DecodeUntrusted, )] pub enum Purpose { /// at least one authentication key must be registered for all security levels diff --git a/packages/rs-dpp/src/identity/identity_public_key/security_level.rs b/packages/rs-dpp/src/identity/identity_public_key/security_level.rs index a907fd28104..eacf4c4f2e8 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/security_level.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/security_level.rs @@ -1,4 +1,4 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "cbor")] use ciborium::value::Value as CborValue; @@ -26,6 +26,7 @@ use std::convert::TryFrom; Decode, Default, strum::EnumIter, + DecodeUntrusted, )] pub enum SecurityLevel { MASTER = 0, diff --git a/packages/rs-dpp/src/identity/identity_public_key/v0/mod.rs b/packages/rs-dpp/src/identity/identity_public_key/v0/mod.rs index d03356ab7db..b0e2a3041f0 100644 --- a/packages/rs-dpp/src/identity/identity_public_key/v0/mod.rs +++ b/packages/rs-dpp/src/identity/identity_public_key/v0/mod.rs @@ -8,7 +8,7 @@ pub use crate::identity::KeyType; pub use crate::identity::Purpose; pub use crate::identity::SecurityLevel; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; @@ -37,6 +37,7 @@ use crate::state_transition::public_key_in_creation::v0::IdentityPublicKeyInCrea Ord, PartialOrd, Hash, + DecodeUntrusted, )] #[serde(rename_all = "camelCase")] pub struct IdentityPublicKeyV0 { diff --git a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs index 247561ffec8..c369f8ec16a 100644 --- a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs +++ b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs @@ -192,3 +192,7 @@ mod json_convertible_tests { assert_eq!(txid_from_str.as_byte_array(), &raw); } } + +// This graph decodes raw proof fields through Serde before validating the +// consensus bytes. The untrusted adapter suppresses allocation hints. +impl<'de> bincode::serde::DeserializeUntrusted<'de> for ChainAssetLockProof {} diff --git a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs index da051ae7bd8..32a0680c169 100644 --- a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs +++ b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs @@ -489,3 +489,7 @@ mod json_convertible_tests_instantassetlockproof { assert_eq!(original, recovered); } } + +// This graph decodes raw proof fields through Serde before validating the +// consensus bytes. The untrusted adapter suppresses allocation hints. +impl<'de> bincode::serde::DeserializeUntrusted<'de> for InstantAssetLockProof {} diff --git a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/mod.rs b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/mod.rs index 3c6b8684490..1b18ace5388 100644 --- a/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/mod.rs +++ b/packages/rs-dpp/src/identity/state_transition/asset_lock_proof/mod.rs @@ -4,7 +4,7 @@ use dashcore::{OutPoint, Transaction}; use serde::{Deserialize, Deserializer, Serialize}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; pub use instant::*; use platform_value::Value; @@ -34,7 +34,7 @@ pub mod validate_asset_lock_transaction_structure; // unions exposed to JS (see `AddressWitness`, `AddressFundsFeeStrategyStep`). // Bincode `Encode`/`Decode` derives are independent of serde, so consensus // binary format is unaffected. -#[derive(Clone, Debug, Eq, PartialEq, Serialize, Encode, Decode)] +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Encode, Decode, DecodeUntrusted)] #[serde(tag = "$type", rename_all = "camelCase")] #[allow(clippy::large_enum_variant)] pub enum AssetLockProof { diff --git a/packages/rs-dpp/src/identity/v0/mod.rs b/packages/rs-dpp/src/identity/v0/mod.rs index a730aca3187..fd106792577 100644 --- a/packages/rs-dpp/src/identity/v0/mod.rs +++ b/packages/rs-dpp/src/identity/v0/mod.rs @@ -22,13 +22,16 @@ use platform_value::Value; use crate::errors::ProtocolError; use crate::identifier::Identifier; #[cfg(feature = "identity-serialization")] -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; /// Implement the Identity. Identity is a low-level construct that provides the foundation /// for user-facing functionality on the platform #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[derive(Default, Debug, Clone, Eq, PartialEq)] -#[cfg_attr(feature = "identity-serialization", derive(Encode, Decode))] +#[cfg_attr( + feature = "identity-serialization", + derive(Encode, Decode, DecodeUntrusted) +)] #[cfg_attr( feature = "serde-conversion", derive(serde::Serialize, serde::Deserialize), diff --git a/packages/rs-dpp/src/metadata.rs b/packages/rs-dpp/src/metadata.rs index 6dccb0de2df..e750321e4f2 100644 --- a/packages/rs-dpp/src/metadata.rs +++ b/packages/rs-dpp/src/metadata.rs @@ -1,4 +1,4 @@ -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use platform_serialization::de::Decode; use serde::{Deserialize, Serialize}; @@ -8,7 +8,18 @@ use crate::{errors::ProtocolError, prelude::TimestampMillis, util::deserializer: #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[derive( - Serialize, Deserialize, Encode, Decode, Debug, Default, Clone, Copy, PartialEq, PartialOrd, Eq, + Serialize, + Deserialize, + Encode, + Decode, + Debug, + Default, + Clone, + Copy, + PartialEq, + PartialOrd, + Eq, + DecodeUntrusted, )] #[serde(rename_all = "camelCase")] pub struct Metadata { diff --git a/packages/rs-dpp/src/serialization/mod.rs b/packages/rs-dpp/src/serialization/mod.rs index b609b2aa0a1..b50bf581cb3 100644 --- a/packages/rs-dpp/src/serialization/mod.rs +++ b/packages/rs-dpp/src/serialization/mod.rs @@ -25,3 +25,5 @@ pub use json::safe_integer::{ #[cfg(feature = "json-conversion")] pub use json::JsonSafeFields; pub use serialization_traits::*; + +pub(crate) mod untrusted; diff --git a/packages/rs-dpp/src/serialization/serialization_traits.rs b/packages/rs-dpp/src/serialization/serialization_traits.rs index 760e8692455..537a7010a0e 100644 --- a/packages/rs-dpp/src/serialization/serialization_traits.rs +++ b/packages/rs-dpp/src/serialization/serialization_traits.rs @@ -60,30 +60,58 @@ pub trait PlatformSerializableWithPlatformVersion { } } -pub trait PlatformDeserializable { - fn deserialize_from_bytes(data: &[u8]) -> Result +/// Deserialization of bytes this node wrote itself: Drive state read back +/// from GroveDB, wallet storage, locally generated fixtures. +/// +/// Runs bincode's ordinary decoder, which reserves each collection from its +/// length prefix, so it must never see bytes that arrived from a peer, a +/// client, a proof or a host caller; those go through +/// [`PlatformDeserializableUntrusted`]. +pub trait PlatformDeserializableTrusted { + fn deserialize_from_bytes_trusted(data: &[u8]) -> Result + where + Self: Sized, + { + Self::deserialize_from_bytes_trusted_no_limit(data) + } + + fn deserialize_from_bytes_trusted_no_limit(data: &[u8]) -> Result + where + Self: Sized; +} + +/// Deserialization of bytes from outside this node: state transitions, query +/// requests and cursors, proofs, SDK responses, host-supplied input. +/// +/// Runs bincode's untrusted decoder, which reserves nothing from a length +/// prefix before the elements it announces have actually been read, so a +/// short input claiming a huge collection fails instead of allocating. +pub trait PlatformDeserializableUntrusted { + fn deserialize_from_bytes_untrusted(data: &[u8]) -> Result where Self: Sized, { - Self::deserialize_from_bytes_no_limit(data) + Self::deserialize_from_bytes_untrusted_no_limit(data) } - fn deserialize_from_bytes_no_limit(data: &[u8]) -> Result + fn deserialize_from_bytes_untrusted_no_limit(data: &[u8]) -> Result where Self: Sized; } -pub trait PlatformDeserializableFromVersionedStructure { - /// We will deserialize a versioned structure into a code structure - /// For example we have DataContractV0 and DataContractV1 - /// The system version will tell which version to deserialize into - /// This happens by first deserializing the data into a potentially versioned structure - /// For example we could have DataContractSerializationFormatV0 and DataContractSerializationFormatV1 - /// Both of the structures will be valid in perpetuity as they are saved into the state. - /// So from the bytes we could get DataContractSerializationFormatV0. - /// Then the system_version given will tell to transform DataContractSerializationFormatV0 into - /// DataContractV1 (if system version is 1) - fn versioned_deserialize( +/// We will deserialize a versioned structure into a code structure +/// For example we have DataContractV0 and DataContractV1 +/// The system version will tell which version to deserialize into +/// This happens by first deserializing the data into a potentially versioned structure +/// For example we could have DataContractSerializationFormatV0 and DataContractSerializationFormatV1 +/// Both of the structures will be valid in perpetuity as they are saved into the state. +/// So from the bytes we could get DataContractSerializationFormatV0. +/// Then the system_version given will tell to transform DataContractSerializationFormatV0 into +/// DataContractV1 (if system version is 1) +/// +/// Trusted twin: bytes this node wrote itself, see [`PlatformDeserializableTrusted`]. +pub trait PlatformDeserializableFromVersionedStructureTrusted { + fn versioned_deserialize_trusted( data: &[u8], platform_version: &PlatformVersion, ) -> Result @@ -91,88 +119,96 @@ pub trait PlatformDeserializableFromVersionedStructure { Self: Sized; } -pub trait PlatformDeserializableWithPotentialValidationFromVersionedStructure { - /// We will deserialize a versioned structure into a code structure - /// For example we have DataContractV0 and DataContractV1 - /// The system version will tell which version to deserialize into - /// This happens by first deserializing the data into a potentially versioned structure - /// For example we could have DataContractSerializationFormatV0 and DataContractSerializationFormatV1 - /// Both of the structures will be valid in perpetuity as they are saved into the state. - /// So from the bytes we could get DataContractSerializationFormatV0. - /// Then the system_version given will tell to transform DataContractSerializationFormatV0 into - /// DataContractV1 (if system version is 1) - fn versioned_deserialize( +/// Untrusted twin of [`PlatformDeserializableFromVersionedStructureTrusted`]: +/// bytes from outside this node, see [`PlatformDeserializableUntrusted`]. +pub trait PlatformDeserializableFromVersionedStructureUntrusted { + fn versioned_deserialize_untrusted( data: &[u8], - full_validation: bool, platform_version: &PlatformVersion, ) -> Result where Self: Sized; } -pub trait PlatformDeserializableWithBytesLenFromVersionedStructure { - /// We will deserialize a versioned structure into a code structure - /// For example we have DataContractV0 and DataContractV1 - /// The system version will tell which version to deserialize into - /// This happens by first deserializing the data into a potentially versioned structure - /// For example we could have DataContractSerializationFormatV0 and DataContractSerializationFormatV1 - /// Both of the structures will be valid in perpetuity as they are saved into the state. - /// So from the bytes we could get DataContractSerializationFormatV0. - /// Then the system_version given will tell to transform DataContractSerializationFormatV0 into - /// DataContractV1 (if system version is 1) - fn versioned_deserialize_with_bytes_len( +/// Versioned deserialization with optional full validation of the decoded +/// structure (see [`PlatformDeserializableFromVersionedStructureTrusted`] for +/// how versioned structures decode). +/// +/// Trusted twin: bytes this node wrote itself, see [`PlatformDeserializableTrusted`]. +pub trait PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, - ) -> Result<(Self, usize), ProtocolError> + ) -> Result where Self: Sized; } -pub trait PlatformLimitDeserializableFromVersionedStructure { - fn versioned_limit_deserialize( +/// Untrusted twin of +/// [`PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted`]: +/// bytes from outside this node, see [`PlatformDeserializableUntrusted`]. +pub trait PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted { + fn versioned_deserialize_untrusted( data: &[u8], + full_validation: bool, platform_version: &PlatformVersion, ) -> Result where Self: Sized; } -/// Convert to/from `platform_value::Value` using **non-human-readable** serde -/// (`Identifier` = `Value::Identifier(bytes)`, binary = `Value::Bytes(bytes)`, -/// raw byte fields preserved without stringification). +/// Versioned deserialization that also reports how many bytes were consumed +/// (see [`PlatformDeserializableFromVersionedStructureTrusted`] for how +/// versioned structures decode). /// -/// # ⚠️ HR / non-HR divergence (Critical-1) -/// -/// `ValueConvertible` calls `platform_value::to_value`, which uses a serializer -/// that reports `is_human_readable() == false`. The mirror trait -/// [`JsonConvertible`] uses `serde_json::to_value`, which reports `true`. -/// Types whose `Serialize` impl branches on `is_human_readable()` produce -/// **structurally different output** between the two paths: -/// -/// | Type | `to_json()` (HR) | `to_object()` (non-HR) | -/// |---|---|---| -/// | [`platform_value::Identifier`] | `"5bV6jUfh..."` (bs58 string) | `Value::Identifier([u8; 32])` | -/// | [`platform_value::BinaryData`] | `"sg=="` (base64 string) | `Value::Bytes(Vec)` | -/// | `Bytes20` / `Bytes32` / `Bytes36` | base64 string | `Value::Bytes32([u8; N])` etc. | -/// | `CoreScript` | `"dqkU..."` (base64 string) | `Value::Bytes(Vec)` | -/// -/// **Do not assume** `self.to_object()?.try_into_json()` ≡ `self.to_json()`. -/// They render the same field as a string in one and a byte array in the -/// other. Round-trip tests should exercise each path independently. -/// -/// # ⚠️ `ContentDeserializer` caveat +/// Trusted twin: bytes this node wrote itself, see [`PlatformDeserializableTrusted`]. +pub trait PlatformDeserializableWithBytesLenFromVersionedStructureTrusted { + fn versioned_deserialize_with_bytes_len_trusted( + data: &[u8], + full_validation: bool, + platform_version: &PlatformVersion, + ) -> Result<(Self, usize), ProtocolError> + where + Self: Sized; +} + +/// Untrusted twin of +/// [`PlatformDeserializableWithBytesLenFromVersionedStructureTrusted`]: +/// bytes from outside this node, see [`PlatformDeserializableUntrusted`]. +pub trait PlatformDeserializableWithBytesLenFromVersionedStructureUntrusted { + fn versioned_deserialize_with_bytes_len_untrusted( + data: &[u8], + full_validation: bool, + platform_version: &PlatformVersion, + ) -> Result<(Self, usize), ProtocolError> + where + Self: Sized; +} + +/// Versioned deserialization under the type's configured byte limit. /// -/// Manual `Deserialize` impls that branch on `deserializer.is_human_readable()` -/// must also handle `serde::__private::de::ContentDeserializer`, used -/// internally by `#[serde(tag = "...")]` enums. ContentDeserializer **always -/// reports `is_human_readable: true`** regardless of the original source, so -/// a non-HR `platform_value::Value` flowing into a tagged enum gets shape- -/// inferred as if it were HR. Recipe: write a dual-shape visitor accepting -/// both shapes in the HR branch via `deserialize_any`. See -/// [`platform_value::Bytes32::deserialize`] for the canonical example, and -/// `rs-dpp/src/serialization/serde_bytes.rs` for `[u8; N]` / `Vec`. -#[cfg(feature = "value-conversion")] +/// Trusted twin: bytes this node wrote itself, see [`PlatformDeserializableTrusted`]. +pub trait PlatformLimitDeserializableFromVersionedStructureTrusted { + fn versioned_limit_deserialize_trusted( + data: &[u8], + platform_version: &PlatformVersion, + ) -> Result + where + Self: Sized; +} + +/// Untrusted twin of [`PlatformLimitDeserializableFromVersionedStructureTrusted`]: +/// bytes from outside this node, see [`PlatformDeserializableUntrusted`]. +pub trait PlatformLimitDeserializableFromVersionedStructureUntrusted { + fn versioned_limit_deserialize_untrusted( + data: &[u8], + platform_version: &PlatformVersion, + ) -> Result + where + Self: Sized; +} + pub trait ValueConvertible: Serialize + DeserializeOwned { fn to_object(&self) -> Result where diff --git a/packages/rs-dpp/src/serialization/untrusted.rs b/packages/rs-dpp/src/serialization/untrusted.rs new file mode 100644 index 00000000000..74b9b8b0afb --- /dev/null +++ b/packages/rs-dpp/src/serialization/untrusted.rs @@ -0,0 +1,18 @@ +//! Explicit adapters for foreign Serde types in Platform's binary wire format. + +/// Txid's binary Serde visitor accepts exactly 32 bytes. The transparent wrapper +/// preserves its length-prefixed wire encoding while opting this specific graph +/// into the guarded Serde adapter; it does not opt in arbitrary Dash Core types. +#[derive(serde::Deserialize)] +#[serde(transparent)] +struct UntrustedTxid(dashcore::Txid); + +impl<'de> bincode::serde::DeserializeUntrusted<'de> for UntrustedTxid {} + +pub(crate) fn decode_txid( + decoder: &mut D, +) -> Result { + let bincode::serde::Compat(UntrustedTxid(txid)) = + bincode::DecodeUntrusted::decode_untrusted(decoder)?; + Ok(txid) +} diff --git a/packages/rs-dpp/src/shielded/mod.rs b/packages/rs-dpp/src/shielded/mod.rs index f0b553f9aee..2298376f250 100644 --- a/packages/rs-dpp/src/shielded/mod.rs +++ b/packages/rs-dpp/src/shielded/mod.rs @@ -7,7 +7,7 @@ mod sighash; pub use memo::{ShieldedMemo, MEMO_PAYLOAD_SIZE, MEMO_SIZE}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -162,7 +162,7 @@ pub struct OrchardBundleParams { /// Keeps the wire shape (Uint8Array in binary, base64 string in JSON) without /// per-field annotations. #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/mod.rs b/packages/rs-dpp/src/state_transition/mod.rs index 4ee39893cda..8ffac4cf8bf 100644 --- a/packages/rs-dpp/src/state_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/mod.rs @@ -8,7 +8,7 @@ use std::ops::RangeInclusive; use platform_value::{BinaryData, Identifier}; pub use state_transition_types::*; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(any( feature = "state-transition-signing", feature = "state-transition-validation" @@ -16,7 +16,9 @@ use bincode::{Decode, Encode}; use dashcore::signer; #[cfg(feature = "state-transition-validation")] use dashcore::signer::double_sha; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::{PlatformVersion, ProtocolVersion, ALL_VERSIONS, LATEST_VERSION}; #[cfg(any( @@ -73,7 +75,7 @@ use crate::identity::Purpose; use crate::identity::{IdentityPublicKey, KeyType}; use crate::identity::{KeyID, SecurityLevel}; use crate::prelude::{AddressNonce, AssetLockProof, UserFeeIncrease}; -use crate::serialization::{PlatformDeserializable, Signable}; +use crate::serialization::{PlatformDeserializableUntrusted, Signable}; use crate::state_transition::address_credit_withdrawal_transition::{ AddressCreditWithdrawalTransition, AddressCreditWithdrawalTransitionSignable, }; @@ -454,10 +456,12 @@ macro_rules! call_errorable_method_identity_signed { Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, From, PartialEq, + DecodeUntrusted, )] // `tag = "$type"` matches the system-field convention: every serde-injected // discriminator key in this crate carries a `$` prefix so it never collides @@ -839,7 +843,7 @@ pub struct StateTransitionSigningOptions { impl StateTransition { #[allow(unused_variables)] - pub fn deserialize_from_bytes_in_version( + pub fn deserialize_from_bytes_untrusted_in_version( bytes: &[u8], platform_version: &PlatformVersion, ) -> Result { @@ -849,7 +853,7 @@ impl StateTransition { .map(usize::from); let state_transition = platform_value::with_value_decode_depth_limit(max_value_depth, || { - StateTransition::deserialize_from_bytes(bytes) + StateTransition::deserialize_from_bytes_untrusted(bytes) })?; #[cfg(all(feature = "state-transitions", feature = "validation"))] { @@ -2385,12 +2389,12 @@ mod tests { #[test] fn test_state_transition_platform_serialize_roundtrip() { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; let original = sample_transfer_st(); let bytes = PlatformSerializable::serialize_to_bytes(&original).expect("serialize should succeed"); - let restored = - StateTransition::deserialize_from_bytes(&bytes).expect("deserialize should succeed"); + let restored = StateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("deserialize should succeed"); assert_eq!(original, restored); } @@ -2400,9 +2404,11 @@ mod tests { let original = sample_transfer_st(); let bytes = PlatformSerializable::serialize_to_bytes(&original).expect("serialize succeeds"); - let restored = - StateTransition::deserialize_from_bytes_in_version(&bytes, PlatformVersion::latest()) - .expect("deserialize_from_bytes_in_version should succeed"); + let restored = StateTransition::deserialize_from_bytes_untrusted_in_version( + &bytes, + PlatformVersion::latest(), + ) + .expect("deserialize_from_bytes_in_version should succeed"); assert_eq!(original, restored); } @@ -3215,34 +3221,34 @@ mod tests { // --- serialize round-trip for variants beyond credit transfer. --- #[test] fn test_serialize_roundtrip_identity_update() { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; let original = sample_identity_update_st(); let bytes = PlatformSerializable::serialize_to_bytes(&original).expect("serialize should succeed"); - let restored = - StateTransition::deserialize_from_bytes(&bytes).expect("deserialize should succeed"); + let restored = StateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("deserialize should succeed"); assert_eq!(original, restored); } #[test] fn test_serialize_roundtrip_data_contract_update() { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; let original = sample_data_contract_update_st(); let bytes = PlatformSerializable::serialize_to_bytes(&original).expect("serialize should succeed"); - let restored = - StateTransition::deserialize_from_bytes(&bytes).expect("deserialize should succeed"); + let restored = StateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("deserialize should succeed"); assert_eq!(original, restored); } #[test] fn test_serialize_roundtrip_batch_empty() { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; let original = sample_batch_st_empty(); let bytes = PlatformSerializable::serialize_to_bytes(&original).expect("serialize should succeed"); - let restored = - StateTransition::deserialize_from_bytes(&bytes).expect("deserialize should succeed"); + let restored = StateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("deserialize should succeed"); assert_eq!(original, restored); } @@ -3272,7 +3278,7 @@ mod tests { low_version.protocol_version ); - let err = StateTransition::deserialize_from_bytes_in_version(&bytes, low_version) + let err = StateTransition::deserialize_from_bytes_untrusted_in_version(&bytes, low_version) .expect_err("expected StateTransitionIsNotActiveError for sub-12 protocol"); match err { ProtocolError::StateTransitionError( @@ -3399,10 +3405,11 @@ mod tests { #[test] fn test_withdrawal_v1_serialize_roundtrip_via_state_transition() { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; let original = sample_withdrawal_v1_st(); let bytes = PlatformSerializable::serialize_to_bytes(&original).expect("serialize ok"); - let restored = StateTransition::deserialize_from_bytes(&bytes).expect("deserialize ok"); + let restored = + StateTransition::deserialize_from_bytes_untrusted(&bytes).expect("deserialize ok"); assert_eq!(original, restored); // The restored variant must still be V1, not V0 — exercises the // feature-version dispatch in deserialize. diff --git a/packages/rs-dpp/src/state_transition/serialization.rs b/packages/rs-dpp/src/state_transition/serialization.rs index 81425f9c6d2..c3e12dbb61c 100644 --- a/packages/rs-dpp/src/state_transition/serialization.rs +++ b/packages/rs-dpp/src/state_transition/serialization.rs @@ -1,12 +1,16 @@ -use crate::serialization::PlatformDeserializable; +use crate::serialization::PlatformDeserializableUntrusted; use crate::state_transition::StateTransition; use crate::ProtocolError; impl StateTransition { - pub fn deserialize_many(raw_state_transitions: &[Vec]) -> Result, ProtocolError> { + pub fn deserialize_many_untrusted( + raw_state_transitions: &[Vec], + ) -> Result, ProtocolError> { raw_state_transitions .iter() - .map(|raw_state_transition| Self::deserialize_from_bytes(raw_state_transition)) + .map(|raw_state_transition| { + Self::deserialize_from_bytes_untrusted(raw_state_transition) + }) .collect() } } @@ -28,7 +32,7 @@ mod tests { use crate::prelude::AssetLockProof; use crate::serialization::PlatformMessageSignable; use crate::serialization::Signable; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::data_contract_create_transition::DataContractCreateTransition; use crate::state_transition::data_contract_update_transition::{ DataContractUpdateTransition, DataContractUpdateTransitionV0, @@ -81,7 +85,7 @@ mod tests { let raw_transaction = STANDARD .decode(RAW_TRANSACTION_BASE64) .expect("base64 transaction should decode"); - let state_transition = StateTransition::deserialize_from_bytes(&raw_transaction) + let state_transition = StateTransition::deserialize_from_bytes_untrusted(&raw_transaction) .expect("State transition deserializes correctly"); assert_eq!( @@ -137,7 +141,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -160,7 +164,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -227,7 +231,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -294,7 +298,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -320,7 +324,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -343,7 +347,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -371,7 +375,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -417,7 +421,7 @@ mod tests { let bytes = state_transition .serialize_to_bytes() .expect("expected to serialize"); - let recovered_state_transition = StateTransition::deserialize_from_bytes(&bytes) + let recovered_state_transition = StateTransition::deserialize_from_bytes_untrusted(&bytes) .expect("expected to deserialize state transition"); assert_eq!(state_transition, recovered_state_transition); } @@ -479,7 +483,7 @@ mod tests { // its recursive data during drop so this regression test only exercises decoder behavior. std::mem::forget(state_transition); - let error = StateTransition::deserialize_from_bytes_in_version( + let error = StateTransition::deserialize_from_bytes_untrusted_in_version( &bytes, PlatformVersion::latest(), ) @@ -534,7 +538,7 @@ mod tests { .serialize_to_bytes() .expect("the state transition should encode below the byte limit"); - let recovered = StateTransition::deserialize_from_bytes_in_version( + let recovered = StateTransition::deserialize_from_bytes_untrusted_in_version( &bytes, PlatformVersion::latest(), ) @@ -545,7 +549,7 @@ mod tests { #[test] fn deserialize_empty_bytes_should_fail() { - let result = StateTransition::deserialize_from_bytes(&[]); + let result = StateTransition::deserialize_from_bytes_untrusted(&[]); assert!( result.is_err(), "deserialization of empty bytes should fail" @@ -554,7 +558,7 @@ mod tests { #[test] fn deserialize_single_byte_should_fail() { - let result = StateTransition::deserialize_from_bytes(&[0xFF]); + let result = StateTransition::deserialize_from_bytes_untrusted(&[0xFF]); assert!( result.is_err(), "deserialization of a single 0xFF byte should fail" @@ -586,21 +590,21 @@ mod tests { // Truncate to half let half = &bytes[..bytes.len() / 2]; assert!( - StateTransition::deserialize_from_bytes(half).is_err(), + StateTransition::deserialize_from_bytes_untrusted(half).is_err(), "deserialization of truncated-to-half bytes should fail" ); // Truncate by removing last byte let minus_one = &bytes[..bytes.len() - 1]; assert!( - StateTransition::deserialize_from_bytes(minus_one).is_err(), + StateTransition::deserialize_from_bytes_untrusted(minus_one).is_err(), "deserialization of bytes missing last byte should fail" ); // Keep only first byte let first_only = &bytes[..1]; assert!( - StateTransition::deserialize_from_bytes(first_only).is_err(), + StateTransition::deserialize_from_bytes_untrusted(first_only).is_err(), "deserialization of only the first byte should fail" ); } @@ -632,7 +636,7 @@ mod tests { bytes[mid] ^= 0xFF; // Should either fail or return a different value - must not panic - let result = StateTransition::deserialize_from_bytes(&bytes); + let result = StateTransition::deserialize_from_bytes_untrusted(&bytes); if let Ok(recovered) = result { assert_ne!( state_transition, recovered, @@ -675,7 +679,7 @@ mod tests { // Craft a small payload (~80 bytes) with a Vec field claiming 8 GB. // Without the limit fix this would attempt `vec![0u8; 8_000_000_000]` and abort. let payload = craft_oversized_vec_payload(8_000_000_000); - let result = StateTransition::deserialize_from_bytes(&payload); + let result = StateTransition::deserialize_from_bytes_untrusted(&payload); // Must return an error, not OOM-abort the process assert!( result.is_err(), @@ -691,7 +695,7 @@ mod tests { // or UnexpectedEnd depending on the exact code path). Either way, the // deserialization must fail safely without OOM. let payload = craft_oversized_vec_payload(200_000); - let result = StateTransition::deserialize_from_bytes(&payload); + let result = StateTransition::deserialize_from_bytes_untrusted(&payload); assert!( result.is_err(), "Vec length exceeding byte budget must be rejected" @@ -704,23 +708,23 @@ mod tests { // should NOT reject it for byte budget reasons (it will still fail // because the data doesn't actually contain 200,000 bytes). let payload = craft_oversized_vec_payload(200_000); - let result = StateTransition::deserialize_from_bytes_no_limit(&payload); + let result = StateTransition::deserialize_from_bytes_untrusted_no_limit(&payload); assert!(result.is_err()); // any other error is fine — the data is garbage if let ProtocolError::MaxEncodedBytesReachedError { .. } = result.unwrap_err() { - panic!("deserialize_from_bytes_no_limit should NOT enforce byte budget"); + panic!("deserialize_from_bytes_untrusted_no_limit should NOT enforce byte budget"); } } #[test] fn deserialize_many_empty_list() { - let result = StateTransition::deserialize_many(&[]); + let result = StateTransition::deserialize_many_untrusted(&[]); assert_eq!(result.unwrap(), vec![]); } #[test] fn deserialize_many_with_invalid_entry() { - let result = StateTransition::deserialize_many(&[vec![0xFF]]); + let result = StateTransition::deserialize_many_untrusted(&[vec![0xFF]]); assert!( result.is_err(), "deserialize_many with invalid entry should fail" @@ -759,7 +763,8 @@ mod tests { st3.serialize_to_bytes().unwrap(), ]; - let recovered = StateTransition::deserialize_many(&raw).expect("should deserialize all"); + let recovered = + StateTransition::deserialize_many_untrusted(&raw).expect("should deserialize all"); assert_eq!(recovered.len(), 3); assert_eq!(recovered[0], st1); assert_eq!(recovered[1], st2); diff --git a/packages/rs-dpp/src/state_transition/state_transition_factory.rs b/packages/rs-dpp/src/state_transition/state_transition_factory.rs index d9dbf09d699..a4fa9f93c6e 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_factory.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_factory.rs @@ -1,7 +1,7 @@ use crate::consensus::basic::decode::SerializedObjectParsingError; use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; -use crate::serialization::PlatformDeserializable; +use crate::serialization::PlatformDeserializableUntrusted; use crate::state_transition::StateTransition; use crate::ProtocolError; @@ -10,7 +10,7 @@ pub struct StateTransitionFactory; impl StateTransitionFactory { pub fn create_from_buffer(&self, buffer: &[u8]) -> Result { - StateTransition::deserialize_from_bytes(buffer).map_err(|e| { + StateTransition::deserialize_from_bytes_untrusted(buffer).map_err(|e| { ConsensusError::BasicError(BasicError::SerializedObjectParsingError( SerializedObjectParsingError::new(format!("Decode protocol entity: {:#?}", e)), )) diff --git a/packages/rs-dpp/src/state_transition/state_transition_types.rs b/packages/rs-dpp/src/state_transition/state_transition_types.rs index 647ad3a0e90..2c77418ada3 100644 --- a/packages/rs-dpp/src/state_transition/state_transition_types.rs +++ b/packages/rs-dpp/src/state_transition/state_transition_types.rs @@ -1,4 +1,4 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use num_enum::{IntoPrimitive, TryFromPrimitive}; use serde_repr::{Deserialize_repr, Serialize_repr}; @@ -17,6 +17,7 @@ use serde_repr::{Deserialize_repr, Serialize_repr}; Encode, Decode, Default, + DecodeUntrusted, )] pub enum StateTransitionType { #[default] diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/mod.rs index dea5bac2b39..49124686158 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/mod.rs @@ -19,11 +19,13 @@ use crate::state_transition::StateTransitionFieldTypes; use crate::balances::credits::CREDITS_PER_DUFF; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::transaction::special_transaction::asset_unlock::qualified_asset_unlock::ASSET_UNLOCK_TX_SIZE; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -53,12 +55,14 @@ const _: () = assert!( Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/mod.rs index f3e3be8a864..4d3b76c9f4f 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/mod.rs @@ -4,7 +4,7 @@ mod types; pub(super) mod v0_methods; mod version; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -18,7 +18,7 @@ use crate::serialization::json_safe_fields; use crate::{identity::core_script::CoreScript, withdrawal::Pooling, ProtocolError}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/mod.rs index 24da90075ff..066bd808a57 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/mod.rs @@ -22,10 +22,12 @@ use crate::state_transition::address_funding_from_asset_lock_transition::v0::Add use crate::state_transition::StateTransitionFieldTypes; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -38,12 +40,14 @@ pub type AddressFundingFromAssetLockTransitionLatest = AddressFundingFromAssetLo Clone, Decode, Encode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/v0/mod.rs index 07977f737af..c6c569bb18d 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funding_from_asset_lock_transition/v0/mod.rs @@ -7,7 +7,7 @@ mod version; use std::collections::BTreeMap; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use crate::ProtocolError; @@ -33,7 +33,7 @@ mod property_names { } #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/mod.rs index ff14bdc6473..f811240b216 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/mod.rs @@ -19,9 +19,11 @@ use crate::state_transition::StateTransitionFieldTypes; use crate::identity::state_transition::OptionallyAssetLockProved; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -34,12 +36,14 @@ pub type UTXOTransferTransitionLatest = AddressFundsTransferTransitionV0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs index 52799e2c543..866e39f123c 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/signing_tests.rs @@ -19,7 +19,7 @@ use platform_value::BinaryData; use crate::address_funds::{AddressWitness, PlatformAddress}; use crate::identity::signer::Signer; -use crate::serialization::{PlatformDeserializable, PlatformSerializable, Signable}; +use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, Signable}; use crate::state_transition::address_funds_transfer_transition::methods::AddressFundsTransferTransitionMethodsV0; use crate::state_transition::address_funds_transfer_transition::v0::AddressFundsTransferTransitionV0; use crate::state_transition::StateTransition; @@ -662,8 +662,9 @@ async fn test_signed_transition_serialization_roundtrip() { .expect("should serialize"); // Deserialize - let deserialized = AddressFundsTransferTransitionV0::deserialize_from_bytes(&serialized) - .expect("should deserialize"); + let deserialized = + AddressFundsTransferTransitionV0::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); // Verify equality assert_eq!(transition, deserialized); @@ -706,8 +707,9 @@ async fn test_multisig_transition_serialization_roundtrip() { let serialized = AddressFundsTransferTransitionV0::serialize_to_bytes(&transition) .expect("should serialize"); - let deserialized = AddressFundsTransferTransitionV0::deserialize_from_bytes(&serialized) - .expect("should deserialize"); + let deserialized = + AddressFundsTransferTransitionV0::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); assert_eq!(transition, deserialized); verify_transition_signatures(&deserialized).expect("signatures should still be valid"); @@ -749,8 +751,9 @@ async fn test_mixed_transition_serialization_roundtrip() { let serialized = AddressFundsTransferTransitionV0::serialize_to_bytes(&transition) .expect("should serialize"); - let deserialized = AddressFundsTransferTransitionV0::deserialize_from_bytes(&serialized) - .expect("should deserialize"); + let deserialized = + AddressFundsTransferTransitionV0::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); assert_eq!(transition, deserialized); verify_transition_signatures(&deserialized).expect("signatures should still be valid"); diff --git a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/v0/mod.rs index 061053823b3..aa109be1a31 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_funds_transfer_transition/v0/mod.rs @@ -12,8 +12,10 @@ use crate::prelude::{AddressNonce, UserFeeIncrease}; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -24,9 +26,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -55,21 +59,21 @@ pub struct AddressFundsTransferTransitionV0 { #[cfg(test)] mod test { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::address_funds_transfer_transition::v0::AddressFundsTransferTransitionV0; use std::fmt::Debug; fn address_funds_transfer_transition_serialization_deserialization< - T: PlatformSerializable + PlatformDeserializable + Debug + PartialEq, + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/mod.rs index e42cc3bde14..b40576a3442 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/mod.rs @@ -17,9 +17,11 @@ use crate::data_contract::DataContract; use crate::state_transition::{StateTransition, StateTransitionFieldTypes}; use crate::version::PlatformVersion; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::{TryFromPlatformVersioned, TryIntoPlatformVersioned}; use platform_versioning::PlatformVersioned; @@ -42,12 +44,14 @@ pub type DataContractCreateTransitionLatest = DataContractCreateTransitionV0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/v0/mod.rs index c2ab6fd448a..63fb5a94ff1 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_create_transition/v0/mod.rs @@ -18,7 +18,7 @@ use crate::data_contract::created_data_contract::CreatedDataContract; use crate::data_contract::serialized_version::DataContractInSerializationFormat; use crate::prelude::{IdentityNonce, UserFeeIncrease}; use crate::state_transition::data_contract_create_transition::DataContractCreateTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_version::{TryFromPlatformVersioned, TryIntoPlatformVersioned}; use crate::state_transition::StateTransition; @@ -27,7 +27,7 @@ use crate::version::PlatformVersion; ///DataContractCreateTransitionV0 has the same encoding structure #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PartialEq, PlatformSignable)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/mod.rs index 9299113b8e0..9fb871aadf9 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/mod.rs @@ -4,9 +4,11 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::state_transition::StateTransitionFieldTypes; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; @@ -44,12 +46,14 @@ pub type DataContractUpdateTransitionLatest = DataContractUpdateTransitionV0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/serialize.rs b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/serialize.rs index fbb4507196a..975eb601699 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/serialize.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/serialize.rs @@ -1,7 +1,7 @@ // use crate::data_contract::DataContract; // use crate::document::document_transition::document_base_transition::JsonValue; // use crate::identity::KeyID; -// use crate::serialization::PlatformDeserializable; +// use crate::serialization::PlatformDeserializableUntrusted; // use crate::serialization::PlatformSerializable; // use crate::serialization::Signable; // use crate::state_transition::{ @@ -10,7 +10,7 @@ // use crate::{ ProtocolError}; // use bincode::{config, Decode, Encode}; // use derive_more::From; -// use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +// use platform_serialization_derive::{PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize}; // use platform_value::btreemap_extensions::BTreeValueRemoveFromMapHelper; // use platform_value::{BinaryData, Identifier, Value}; // use serde::de::{MapAccess, Visitor}; diff --git a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/v0/mod.rs index 88be0127bf8..f839a419b71 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/contract/data_contract_update_transition/v0/mod.rs @@ -10,7 +10,7 @@ use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_version::version::PlatformVersion; use platform_version::{TryFromPlatformVersioned, TryIntoPlatformVersioned}; @@ -22,7 +22,7 @@ use crate::state_transition::StateTransition; use crate::{data_contract::DataContract, identity::KeyID, ProtocolError}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PartialEq, PlatformSignable)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/mod.rs index eddb5f55dd7..b9bce475893 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/mod.rs @@ -14,7 +14,7 @@ use crate::state_transition::batch_transition::document_base_transition::v0::{ use crate::state_transition::batch_transition::document_base_transition::v1::DocumentBaseTransitionV1; #[cfg(any(feature = "value-conversion", feature = "json-conversion"))] use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; pub use fields::*; #[cfg(any(feature = "value-conversion", feature = "json-conversion"))] @@ -42,7 +42,7 @@ use std::collections::BTreeMap; // routes `$baseFormatVersion` + the known base struct fields to `base` // before letting the catchall claim what's left. See comments on // those impls for detail. -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v0/mod.rs index cbbd2d40cc4..4ff7ef41343 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v0/mod.rs @@ -4,7 +4,7 @@ pub mod v0_methods; #[cfg(feature = "value-conversion")] use std::collections::BTreeMap; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "value-conversion")] @@ -25,7 +25,7 @@ use crate::state_transition::batch_transition::document_base_transition::propert #[cfg(any(feature = "json-conversion", feature = "value-conversion"))] use crate::{data_contract::DataContract, errors::ProtocolError}; -#[derive(Debug, Clone, Encode, Decode, Default, PartialEq, Display)] +#[derive(Debug, Clone, Encode, Decode, Default, PartialEq, Display, DecodeUntrusted)] // `json_safe_fields` auto-injects `crate::serialization::json_safe_u64` on // `identity_contract_nonce: IdentityNonce` (= u64). Large nonces serialize // as JSON strings to avoid JS Number precision loss; native u64 in non-HR. diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v1/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v1/mod.rs index b3ddc865150..0d662755e61 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v1/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_base_transition/v1/mod.rs @@ -4,7 +4,7 @@ pub mod v1_methods; #[cfg(feature = "value-conversion")] use std::collections::BTreeMap; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "value-conversion")] @@ -23,7 +23,7 @@ use platform_value::Value; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Encode, Decode, Default, PartialEq, Display)] +#[derive(Debug, Clone, Encode, Decode, Default, PartialEq, Display, DecodeUntrusted)] // See `DocumentBaseTransitionV0` for json_safe_fields rationale. #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] #[cfg_attr( diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/mod.rs index 50007d098d0..cffd79d53e1 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/mod.rs @@ -9,7 +9,7 @@ use crate::document::Document; use crate::prelude::DataContract; use crate::state_transition::batch_transition::document_create_transition::v0::DocumentFromCreateTransitionV0; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; use platform_value::Identifier; use platform_version::version::PlatformVersion; @@ -17,7 +17,7 @@ use platform_version::version::PlatformVersion; use serde::{Deserialize, Serialize}; pub use v0::DocumentCreateTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/v0/mod.rs index 876fc29bc10..0b6cf04c165 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_create_transition/v0/mod.rs @@ -1,7 +1,7 @@ mod from_document; pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "value-conversion")] use platform_value::btreemap_extensions::BTreeValueRemoveFromMapHelper; @@ -47,7 +47,7 @@ pub const BINARY_FIELDS: [&str; 1] = ["$entropy"]; /// The Identifier fields in [`DocumentCreateTransition`] pub use super::super::document_base_transition::IDENTIFIER_FIELDS; -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] // `json_safe_fields`: // - Auto-injects `crate::serialization::serde_bytes` on `entropy: [u8; 32]` // → base64 string in JSON HR, raw bytes in non-HR. diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/mod.rs index 24ceccaded5..b90230cd14f 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/mod.rs @@ -2,13 +2,13 @@ mod from_document; pub mod v0; pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::*; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/v0/mod.rs index b6c760bf28a..cee03e5f46b 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_delete_transition/v0/mod.rs @@ -3,7 +3,7 @@ pub mod v0_methods; use crate::state_transition::batch_transition::document_base_transition::DocumentBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "json-conversion")] @@ -14,7 +14,7 @@ use serde::{Deserialize, Serialize}; pub use super::super::document_base_transition::IDENTIFIER_FIELDS; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/mod.rs index c68a990a2ab..2c3ac83cfea 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/mod.rs @@ -2,7 +2,7 @@ mod from_document; pub mod v0; pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -19,7 +19,7 @@ pub use v0::*; /// self-authorizing values) and validation pipeline, which is exactly the /// distinction the repo models as separate `DocumentTransition` kinds. /// The ABCI structure gates pair each kind with its storage mode. -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/v0/mod.rs index 453a4093786..3360fa0e89c 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_index_only_delete_transition/v0/mod.rs @@ -4,7 +4,7 @@ pub mod v0_methods; use crate::state_transition::batch_transition::document_base_transition::DocumentBaseTransition; use std::collections::BTreeMap; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use platform_value::Value; @@ -27,7 +27,7 @@ pub use super::super::document_base_transition::IDENTIFIER_FIELDS; // `Deserialize` is implemented manually below — same reason as // `DocumentCreateTransitionV0`: two `#[serde(flatten)]` fields, one of // which is a catchall map that would otherwise swallow the base's keys. -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/mod.rs index b63157bba34..0b3fceabb0d 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/mod.rs @@ -2,13 +2,13 @@ mod from_document; pub mod v0; pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::*; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/v0/mod.rs index d18bd1a9206..b1281112c65 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_purchase_transition/v0/mod.rs @@ -3,7 +3,7 @@ pub mod v0_methods; use crate::state_transition::batch_transition::document_base_transition::DocumentBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use crate::fee::Credits; @@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize}; pub use super::super::document_base_transition::IDENTIFIER_FIELDS; -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/mod.rs index b3af3e56b0a..03d3fa08797 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/mod.rs @@ -7,7 +7,7 @@ use crate::data_contract::document_type::DocumentTypeRef; use crate::document::Document; use crate::prelude::{BlockHeight, CoreBlockHeight, TimestampMillis}; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; use platform_value::Identifier; use platform_version::version::PlatformVersion; @@ -15,7 +15,7 @@ use platform_version::version::PlatformVersion; use serde::{Deserialize, Serialize}; pub use v0::*; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/v0/mod.rs index b501324e98d..ecdd1d6c47e 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_replace_transition/v0/mod.rs @@ -2,7 +2,7 @@ mod from_document; pub mod v0_methods; use crate::prelude::{BlockHeight, CoreBlockHeight, Revision, TimestampMillis}; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use platform_value::{Identifier, Value}; @@ -25,7 +25,7 @@ mod property_names { pub const REVISION: &str = "$revision"; } -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] // Auto-injects `json_safe_u64` on `revision: Revision` (= u64). #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] // `Deserialize` is implemented manually below — see comments. Same diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/mod.rs index c48178ab83e..2dc61cdb993 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/mod.rs @@ -2,13 +2,13 @@ mod from_document; pub mod v0; pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::*; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/v0/mod.rs index 488291f2f56..3858382360b 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transfer_transition/v0/mod.rs @@ -2,7 +2,7 @@ mod from_document; pub mod v0_methods; use crate::prelude::Revision; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use platform_value::Identifier; @@ -18,7 +18,7 @@ mod property_names { pub const RECIPIENT_OWNER_ID: &str = "recipientOwnerId"; } -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transition.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transition.rs index ab0b9721dc8..1b9c13ddea9 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transition.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_transition.rs @@ -3,7 +3,7 @@ use std::collections::BTreeMap; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -use bincode::{Encode, Decode}; +use bincode::{Encode, Decode, DecodeUntrusted}; use crate::prelude::{IdentityNonce, Revision}; use crate::state_transition::batch_transition::{DocumentCreateTransition, DocumentDeleteTransition, DocumentReplaceTransition, TokenBurnTransition, TokenConfigUpdateTransition, TokenDestroyFrozenFundsTransition, TokenEmergencyActionTransition, TokenFreezeTransition, TokenMintTransition, TokenClaimTransition, TokenTransferTransition, TokenUnfreezeTransition, TokenDirectPurchaseTransition, TokenSetPriceForDirectPurchaseTransition}; use crate::state_transition::batch_transition::batched_transition::{DocumentIndexOnlyDeleteTransition, DocumentPurchaseTransition, DocumentTransferTransition, DocumentUpdatePriceTransition}; @@ -18,7 +18,7 @@ use crate::state_transition::batch_transition::document_create_transition::v0::v use crate::state_transition::batch_transition::document_replace_transition::v0::v0_methods::DocumentReplaceTransitionV0Methods; use crate::state_transition::batch_transition::resolvers::v0::BatchTransitionResolversV0; -#[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display)] +#[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/mod.rs index 7847b3fcc44..41cf0ba73ca 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/mod.rs @@ -2,13 +2,13 @@ mod from_document; pub mod v0; pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::*; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/v0/mod.rs index fe5ca2a4c26..432541f781c 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/document_update_price_transition/v0/mod.rs @@ -2,7 +2,7 @@ mod from_document; pub mod v0_methods; use crate::prelude::Revision; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "serde-conversion")] @@ -17,7 +17,7 @@ mod property_names { pub const REVISION: &str = "$revision"; } -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/mod.rs index b2913834070..a71a4271563 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/mod.rs @@ -1,4 +1,4 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -47,7 +47,7 @@ pub use token_transition::TokenTransition; pub const PROPERTY_ACTION: &str = "$action"; -#[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display)] +#[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/mod.rs index 6fe2cd1549c..0591c28720f 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/mod.rs @@ -9,7 +9,7 @@ use crate::state_transition::batch_transition::document_base_transition::v0::Doc use crate::state_transition::batch_transition::token_base_transition::v0::TokenBaseTransitionV0; #[cfg(any(feature = "value-conversion", feature = "json-conversion"))] use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; pub use fields::*; #[cfg(any(feature = "value-conversion", feature = "json-conversion"))] @@ -30,7 +30,7 @@ use std::collections::BTreeMap; // the flattened base) keeps the entire transition wire shape flat — // matching the convention every consumer reads (`tx["$id"]`, // `tx["$identity-contract-nonce"]`, etc.). -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/v0/mod.rs index 5930e5c2957..0bf14deada3 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_base_transition/v0/mod.rs @@ -3,7 +3,7 @@ pub mod v0_methods; #[cfg(feature = "value-conversion")] use std::collections::BTreeMap; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "value-conversion")] @@ -27,7 +27,7 @@ use crate::tokens::errors::TokenError; #[cfg(any(feature = "json-conversion", feature = "value-conversion"))] use crate::{data_contract::DataContract, errors::ProtocolError}; -#[derive(Debug, Clone, Encode, Decode, Default, PartialEq, Display)] +#[derive(Debug, Clone, Encode, Decode, Default, PartialEq, Display, DecodeUntrusted)] // Auto-injects `json_safe_u64` on `identity_contract_nonce: IdentityNonce` // (= u64) so JSON HR stringifies large values (JS Number precision safety). #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/mod.rs index bd0d92f7bdc..7a4016c28f0 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenBurnTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/v0/mod.rs index 3296b4fef8a..a28cbeb51d8 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_burn_transition/v0/mod.rs @@ -1,7 +1,7 @@ pub mod v0_methods; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -12,7 +12,7 @@ mod property_names { /// The Identifier fields in [`TokenBurnTransition`] pub use super::super::document_base_transition::IDENTIFIER_FIELDS; -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/mod.rs index 1f623cc249b..9391d9a90a0 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenClaimTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/v0/mod.rs index 11831c506af..b6e2cedd5b0 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_claim_transition/v0/mod.rs @@ -6,13 +6,13 @@ use crate::data_contract::associated_token::token_distribution_key::TokenDistrib #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::fmt; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/mod.rs index 004a7d50f38..7c82fec25e1 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenConfigUpdateTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/v0/mod.rs index 9091ee88562..6813e869c85 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_config_update_transition/v0/mod.rs @@ -6,13 +6,13 @@ use crate::data_contract::associated_token::token_configuration_item::TokenConfi #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/mod.rs index 7b731be892f..b4db76f1426 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenDestroyFrozenFundsTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/v0/mod.rs index b33f2e5f0bf..e61824c3246 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_destroy_frozen_funds_transition/v0/mod.rs @@ -3,14 +3,14 @@ pub mod v0_methods; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/mod.rs index 1583ba5370b..ae1e96cef72 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/mod.rs @@ -2,7 +2,7 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -16,7 +16,7 @@ pub use v0::TokenDirectPurchaseTransitionV0; /// /// This transition type is used when a user intends to directly purchase tokens /// by specifying the desired amount and the maximum total price they are willing to pay. -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/v0/mod.rs index dbaa2fffa47..34e30a10a48 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_direct_purchase_transition/v0/mod.rs @@ -3,7 +3,7 @@ pub mod v0_methods; use crate::balances::credits::TokenAmount; use crate::fee::Credits; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::fmt; @@ -11,7 +11,7 @@ use std::fmt; /// The Identifier fields in [`TokenDirectPurchaseTransition`] pub use super::super::document_base_transition::IDENTIFIER_FIELDS; -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] // Auto-injects `json_safe_u64` on `token_count: TokenAmount` and // `total_agreed_price: Credits` (both u64). #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/mod.rs index 529a19443d1..0c062ff60a0 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenEmergencyActionTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/v0/mod.rs index 58ced445bb9..e12fa256e23 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_emergency_action_transition/v0/mod.rs @@ -4,13 +4,13 @@ pub mod v0_methods; use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; use crate::tokens::emergency_action::TokenEmergencyAction; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::fmt; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/mod.rs index 26b68dca2a7..dbdfa720d57 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenFreezeTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/v0/mod.rs index 3bae77be515..7fc5f64dcc5 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_freeze_transition/v0/mod.rs @@ -3,7 +3,7 @@ pub mod v0_methods; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -13,7 +13,7 @@ use std::fmt; pub use super::super::document_base_transition::IDENTIFIER_FIELDS; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/mod.rs index 488a5f46d58..b82c7c3a0e0 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenMintTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0/mod.rs index 360a59d3454..583efb56e4a 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0/mod.rs @@ -1,7 +1,7 @@ pub mod v0_methods; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::string_encoding::Encoding; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] @@ -14,7 +14,7 @@ mod property_names { /// The Identifier fields in [`TokenMintTransition`] pub use super::super::document_base_transition::IDENTIFIER_FIELDS; -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] // Auto-injects `json_safe_u64` on `amount: u64`. #[cfg_attr(feature = "json-conversion", crate::serialization::json_safe_fields)] #[cfg_attr( diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/mod.rs index 2404380b2dc..5bd86aa8b16 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/mod.rs @@ -2,7 +2,7 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -21,7 +21,7 @@ pub use v0::TokenSetPriceForDirectPurchaseTransitionV0; /// /// Versioning enables forward compatibility by allowing future enhancements or changes /// without breaking existing clients. -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/v0/mod.rs index b04050ef21f..56e8a04f18e 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_set_price_for_direct_purchase_transition/v0/mod.rs @@ -6,13 +6,13 @@ pub use super::super::document_base_transition::IDENTIFIER_FIELDS; use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; use crate::tokens::token_pricing_schedule::TokenPricingSchedule; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::fmt; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/mod.rs index bf71e260ad6..c33844251cf 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; pub mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::*; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/v0/mod.rs index 27d783aed9a..06244a32556 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transfer_transition/v0/mod.rs @@ -1,6 +1,6 @@ pub mod v0_methods; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; pub use super::super::token_base_transition::IDENTIFIER_FIELDS; @@ -15,7 +15,7 @@ mod property_names { pub const RECIPIENT_OWNER_ID: &str = "recipientOwnerId"; } -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Display, DecodeUntrusted)] // `json_safe_fields` auto-injects: // - `json_safe_u64` on `amount: u64` (JS-safe stringification when large) // - `json_safe_option_encrypted_note` on `shared_encrypted_note` and diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transition.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transition.rs index 0c6ab3152f9..0269ea0b610 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transition.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_transition.rs @@ -2,7 +2,7 @@ use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use platform_value::Identifier; -use bincode::{Encode, Decode}; +use bincode::{Encode, Decode, DecodeUntrusted}; use platform_version::version::PlatformVersion; use crate::balances::credits::TokenAmount; use crate::block::block_info::BlockInfo; @@ -45,7 +45,7 @@ pub const TOKEN_HISTORY_ID_BYTES: [u8; 32] = [ 187, 110, 233, 128, 63, 48, 172, 29, 210, 108, ]; -#[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display)] +#[derive(Debug, Clone, Encode, Decode, From, PartialEq, Display, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/mod.rs index ca16df71ced..557936417e8 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/mod.rs @@ -2,13 +2,13 @@ pub mod v0; mod v0_methods; pub mod validate_structure; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; pub use v0::TokenUnfreezeTransitionV0; -#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From)] +#[derive(Debug, Clone, Encode, Decode, PartialEq, Display, From, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/v0/mod.rs index 2c6a3d1c90b..717eef9fb70 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_unfreeze_transition/v0/mod.rs @@ -3,7 +3,7 @@ pub mod v0_methods; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::state_transition::batch_transition::token_base_transition::TokenBaseTransition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -13,7 +13,7 @@ use std::fmt; pub use super::super::document_base_transition::IDENTIFIER_FIELDS; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Default, Encode, Decode, PartialEq)] +#[derive(Debug, Clone, Default, Encode, Decode, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/mod.rs index 4be86b2b0e9..b3abe347bbb 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/mod.rs @@ -1,4 +1,4 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use std::convert::TryInto; @@ -33,7 +33,9 @@ pub use self::batched_transition::{ token_unfreeze_transition, token_unfreeze_transition::TokenUnfreezeTransition, }; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; pub mod accessors; @@ -66,11 +68,13 @@ pub use v1::*; PartialEq, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v0/mod.rs index bb0ba1533c9..6d96d6ab424 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v0/mod.rs @@ -8,7 +8,7 @@ use crate::identity::KeyID; use crate::state_transition::state_transitions::document::batch_transition::batched_transition::document_transition::DocumentTransition; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, Encode, DecodeUntrusted}; use platform_serialization_derive::PlatformSignable; use crate::prelude::UserFeeIncrease; @@ -19,7 +19,7 @@ use platform_value::{BinaryData, Identifier}; use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v1/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v1/mod.rs index fbda254cfe0..0c90da22cd4 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v1/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v1/mod.rs @@ -9,7 +9,7 @@ use crate::identity::KeyID; use crate::state_transition::batch_transition::batched_transition::BatchedTransition; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use crate::prelude::UserFeeIncrease; @@ -20,7 +20,7 @@ use platform_value::{BinaryData, Identifier}; use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/mod.rs index aa427159896..e36f7aaef77 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/mod.rs @@ -18,10 +18,12 @@ use crate::state_transition::StateTransitionFieldTypes; use crate::identity::state_transition::OptionallyAssetLockProved; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -34,12 +36,14 @@ pub type IdentityCreateFromAddressesTransitionLatest = IdentityCreateFromAddress Clone, Decode, Encode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/v0/mod.rs index a023e9aae62..3c1f9f2bbd4 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_from_addresses_transition/v0/mod.rs @@ -6,7 +6,7 @@ mod version; use std::collections::BTreeMap; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use crate::address_funds::{AddressFundsFeeStrategy, AddressWitness, PlatformAddress}; @@ -21,7 +21,7 @@ use crate::ProtocolError; use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs index 50f1ae9938f..8d6b944ff30 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/mod.rs @@ -16,10 +16,12 @@ use crate::state_transition::identity_create_transition::v0::IdentityCreateTrans use crate::state_transition::StateTransitionFieldTypes; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -36,12 +38,14 @@ pub type IdentityCreateTransitionLatest = IdentityCreateTransitionV0; Clone, Decode, Encode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -95,7 +99,7 @@ impl StateTransitionFieldTypes for IdentityCreateTransition { mod test { use super::*; use crate::identity::state_transition::asset_lock_proof::AssetLockProof; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0; use crate::state_transition::{ StateTransitionEstimatedFeeValidation, StateTransitionHasUserFeeIncrease, @@ -128,8 +132,8 @@ mod test { fn test_serialization_roundtrip() { let t = make_create(); let bytes = t.serialize_to_bytes().expect("should serialize"); - let restored = - IdentityCreateTransition::deserialize_from_bytes(&bytes).expect("should deserialize"); + let restored = IdentityCreateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("should deserialize"); assert_eq!(t, restored); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/mod.rs index 11b90ce3c09..6371d8db1a7 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_create_transition/v0/mod.rs @@ -8,7 +8,7 @@ mod version; use crate::serialization::json_safe_fields; use std::convert::TryFrom; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_value::BinaryData; @@ -28,7 +28,7 @@ use crate::version::PlatformVersion; use crate::ProtocolError; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/mod.rs index 714db181a71..5d649e13e47 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/mod.rs @@ -19,10 +19,12 @@ use crate::state_transition::StateTransitionFieldTypes; use crate::identity::state_transition::OptionallyAssetLockProved; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -36,12 +38,14 @@ pub type IdentityCreditTransferToAddressesTransitionLatest = Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/v0/mod.rs index 9f25c87f49e..790bb7d4d6e 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_to_addresses_transition/v0/mod.rs @@ -15,8 +15,10 @@ use crate::fee::Credits; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -27,9 +29,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[cfg_attr( @@ -58,7 +62,7 @@ pub struct IdentityCreditTransferToAddressesTransitionV0 { #[cfg(test)] mod test { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_credit_transfer_to_addresses_transition::v0::IdentityCreditTransferToAddressesTransitionV0; use platform_value::Identifier; @@ -66,15 +70,15 @@ mod test { use std::fmt::Debug; fn test_identity_credit_transfer_to_addresses_transition< - T: PlatformSerializable + PlatformDeserializable + Debug + PartialEq, + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/mod.rs index ccb686e8aa6..f1abaf2abf4 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/mod.rs @@ -18,10 +18,12 @@ use crate::state_transition::StateTransitionFieldTypes; use crate::identity::state_transition::OptionallyAssetLockProved; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -38,12 +40,14 @@ pub type IdentityCreditTransferTransitionLatest = IdentityCreditTransferTransiti Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -98,7 +102,7 @@ impl StateTransitionFieldTypes for IdentityCreditTransferTransition { #[cfg(test)] mod test { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_credit_transfer_transition::accessors::IdentityCreditTransferTransitionAccessorsV0; use crate::state_transition::{ StateTransitionEstimatedFeeValidation, StateTransitionHasUserFeeIncrease, @@ -134,7 +138,7 @@ mod test { fn test_serialization_roundtrip() { let transition = make_transfer(); let bytes = transition.serialize_to_bytes().expect("should serialize"); - let restored = IdentityCreditTransferTransition::deserialize_from_bytes(&bytes) + let restored = IdentityCreditTransferTransition::deserialize_from_bytes_untrusted(&bytes) .expect("should deserialize"); assert_eq!(transition, restored); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/v0/mod.rs index 7e12c7d0d42..4dac30f6cdd 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_transfer_transition/v0/mod.rs @@ -11,8 +11,10 @@ use crate::serialization::json_safe_fields; use crate::prelude::{Identifier, IdentityNonce, UserFeeIncrease}; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -24,9 +26,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -51,7 +55,7 @@ pub struct IdentityCreditTransferTransitionV0 { #[cfg(test)] mod test { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_credit_transfer_transition::v0::IdentityCreditTransferTransitionV0; use platform_value::Identifier; @@ -59,15 +63,15 @@ mod test { use std::fmt::Debug; fn test_identity_credit_transfer_transition< - T: PlatformSerializable + PlatformDeserializable + Debug + PartialEq, + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/mod.rs index 2bfe6acc69d..2b9b5d9fd6a 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/mod.rs @@ -23,11 +23,13 @@ use crate::state_transition::identity_credit_withdrawal_transition::v1::{ IdentityCreditWithdrawalTransitionV1, IdentityCreditWithdrawalTransitionV1Signable, }; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use dashcore::transaction::special_transaction::asset_unlock::qualified_asset_unlock::ASSET_UNLOCK_TX_SIZE; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -63,12 +65,14 @@ pub type IdentityCreditWithdrawalTransitionLatest = IdentityCreditWithdrawalTran Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -131,7 +135,7 @@ impl OptionallyAssetLockProved for IdentityCreditWithdrawalTransition {} mod test { use super::*; use crate::identity::core_script::CoreScript; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_credit_withdrawal_transition::accessors::IdentityCreditWithdrawalTransitionAccessorsV0; use crate::state_transition::{ StateTransitionEstimatedFeeValidation, StateTransitionHasUserFeeIncrease, @@ -184,7 +188,7 @@ mod test { fn test_serialization_roundtrip_v0() { let t = make_withdrawal_v0(); let bytes = t.serialize_to_bytes().expect("should serialize"); - let restored = IdentityCreditWithdrawalTransition::deserialize_from_bytes(&bytes) + let restored = IdentityCreditWithdrawalTransition::deserialize_from_bytes_untrusted(&bytes) .expect("should deserialize"); assert_eq!(t, restored); } @@ -193,7 +197,7 @@ mod test { fn test_serialization_roundtrip_v1() { let t = make_withdrawal_v1(); let bytes = t.serialize_to_bytes().expect("should serialize"); - let restored = IdentityCreditWithdrawalTransition::deserialize_from_bytes(&bytes) + let restored = IdentityCreditWithdrawalTransition::deserialize_from_bytes_untrusted(&bytes) .expect("should deserialize"); assert_eq!(t, restored); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v0/mod.rs index fb9a519c6da..b778d1232cc 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v0/mod.rs @@ -5,7 +5,7 @@ mod version; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] @@ -20,7 +20,7 @@ use crate::{ }; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), @@ -50,24 +50,46 @@ mod test { use crate::identity::core_script::CoreScript; use crate::identity::KeyID; use crate::prelude::{IdentityNonce, UserFeeIncrease}; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_credit_withdrawal_transition::v0::Pooling; use crate::ProtocolError; - use bincode::{Decode, Encode}; - use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; + use bincode::{Decode, DecodeUntrusted, Encode}; + use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, + }; use platform_value::{BinaryData, Identifier}; use rand::Rng; use std::fmt::Debug; // Structure with 1 property - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV01 { pub identity_id: Identifier, } // Structure with 2 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV02 { pub identity_id: Identifier, @@ -75,7 +97,17 @@ mod test { } // Structure with 3 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV03 { pub identity_id: Identifier, @@ -84,7 +116,17 @@ mod test { } // Structure with 4 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV04 { pub identity_id: Identifier, @@ -94,7 +136,17 @@ mod test { } // Structure with 5 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV05 { pub identity_id: Identifier, @@ -105,7 +157,17 @@ mod test { } // Structure with 6 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV06 { pub identity_id: Identifier, @@ -117,7 +179,17 @@ mod test { } // Structure with 7 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV07 { pub identity_id: Identifier, @@ -130,7 +202,17 @@ mod test { } // Structure with 8 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV08 { pub identity_id: Identifier, @@ -144,7 +226,17 @@ mod test { } // Structure with 9 properties - #[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] + #[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, + )] #[platform_serialize(unversioned)] struct IdentityCreditWithdrawalTransitionV09 { pub identity_id: Identifier, @@ -159,15 +251,15 @@ mod test { } fn test_identity_credit_withdrawal_transition< - T: PlatformSerializable + PlatformDeserializable + Debug + PartialEq, + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v1/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v1/mod.rs index b445d14700c..02a8adb5fca 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v1/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_credit_withdrawal_transition/v1/mod.rs @@ -6,7 +6,7 @@ mod version; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] @@ -21,7 +21,7 @@ use crate::{ }; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/mod.rs index 92380ff61be..f9c5d323353 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/mod.rs @@ -19,9 +19,11 @@ use crate::state_transition::identity_topup_from_addresses_transition::v0::Ident use crate::state_transition::StateTransitionFieldTypes; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -32,12 +34,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/v0/mod.rs index a25069be018..3a2d26347c3 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_from_addresses_transition/v0/mod.rs @@ -4,7 +4,7 @@ mod types; pub(super) mod v0_methods; mod version; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use std::collections::BTreeMap; @@ -19,7 +19,7 @@ use serde::{Deserialize, Serialize}; use crate::ProtocolError; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs index 74da8481583..38cfc2b44be 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/mod.rs @@ -18,9 +18,11 @@ use crate::state_transition::identity_topup_transition::v0::IdentityTopUpTransit use crate::state_transition::StateTransitionFieldTypes; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -35,12 +37,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/mod.rs index b01df1d247a..939d39de74e 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_topup_transition/v0/mod.rs @@ -6,7 +6,7 @@ mod version; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_value::BinaryData; @@ -29,7 +29,7 @@ mod property_names { } #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, PlatformSignable, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/mod.rs index 26321a944e2..f0bd261ccc9 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/mod.rs @@ -20,9 +20,11 @@ use fields::*; use crate::identity::state_transition::OptionallyAssetLockProved; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -37,12 +39,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -101,7 +105,7 @@ impl StateTransitionFieldTypes for IdentityUpdateTransition { #[cfg(test)] mod test { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::identity_update_transition::accessors::IdentityUpdateTransitionAccessorsV0; use crate::state_transition::{ StateTransitionEstimatedFeeValidation, StateTransitionHasUserFeeIncrease, @@ -137,8 +141,8 @@ mod test { fn test_serialization_roundtrip() { let t = make_update(); let bytes = t.serialize_to_bytes().expect("should serialize"); - let restored = - IdentityUpdateTransition::deserialize_from_bytes(&bytes).expect("should deserialize"); + let restored = IdentityUpdateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("should deserialize"); assert_eq!(t, restored); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/v0/mod.rs index fdf350d6ea3..c4baf5e7905 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/identity_update_transition/v0/mod.rs @@ -6,7 +6,7 @@ mod version; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_value::{BinaryData, Value}; #[cfg(feature = "serde-conversion")] @@ -25,7 +25,7 @@ use crate::{ }; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Encode, Decode, PlatformSignable, Debug, Clone, PartialEq)] +#[derive(Encode, Decode, PlatformSignable, Debug, Clone, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/mod.rs index 573a45ce0c6..4833ee61fb7 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/mod.rs @@ -18,10 +18,12 @@ use crate::state_transition::StateTransitionFieldTypes; use crate::identity::state_transition::OptionallyAssetLockProved; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -38,12 +40,14 @@ pub type MasternodeVoteTransitionLatest = MasternodeVoteTransitionV0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -98,7 +102,7 @@ impl StateTransitionFieldTypes for MasternodeVoteTransition { #[cfg(test)] mod test { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::{ StateTransitionEstimatedFeeValidation, StateTransitionLike, StateTransitionOwned, StateTransitionSingleSigned, StateTransitionType, @@ -146,8 +150,8 @@ mod test { fn test_serialization_roundtrip() { let t = make_vote(); let bytes = t.serialize_to_bytes().expect("should serialize"); - let restored = - MasternodeVoteTransition::deserialize_from_bytes(&bytes).expect("should deserialize"); + let restored = MasternodeVoteTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("should deserialize"); assert_eq!(t, restored); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/v0/mod.rs index 80bf2bae25d..6bcc556434f 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/masternode_vote_transition/v0/mod.rs @@ -12,8 +12,10 @@ use crate::prelude::{Identifier, IdentityNonce}; use crate::protocol_error::ProtocolError; use crate::voting::votes::Vote; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -25,9 +27,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -51,7 +55,7 @@ pub struct MasternodeVoteTransitionV0 { #[cfg(test)] mod test { - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::state_transition::masternode_vote_transition::v0::MasternodeVoteTransitionV0; use crate::voting::vote_choices::resource_vote_choice::ResourceVoteChoice; @@ -65,15 +69,15 @@ mod test { use std::fmt::Debug; fn test_masternode_vote_transition< - T: PlatformSerializable + PlatformDeserializable + Debug + PartialEq, + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/mod.rs index 98ac687de63..05113aa9cff 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/mod.rs @@ -6,7 +6,7 @@ use crate::serialization::ValueConvertible; use crate::state_transition::public_key_in_creation::v0::IdentityPublicKeyInCreationV0; use crate::state_transition::public_key_in_creation::v0::IdentityPublicKeyInCreationV0Signable; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use platform_serialization_derive::PlatformSignable; @@ -25,7 +25,7 @@ mod version; all(feature = "json-conversion", feature = "serde-conversion"), derive(JsonConvertible) )] -#[derive(Debug, Encode, Decode, PlatformSignable, Clone, PartialEq, Eq, From)] +#[derive(Debug, Encode, Decode, PlatformSignable, Clone, PartialEq, Eq, From, DecodeUntrusted)] //here we want to indicate that IdentityPublicKeyInCreation can be transformed into IdentityPublicKeyInCreationSignable #[platform_signable(derive_into)] #[cfg_attr( diff --git a/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/v0/mod.rs index 35d406cffe5..fff252baef4 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/identity/public_key_in_creation/v0/mod.rs @@ -7,7 +7,7 @@ use crate::serialization::json_safe_fields; use std::convert::TryFrom; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::{Deserialize, Serialize}; use platform_value::{BinaryData, Value}; @@ -30,7 +30,17 @@ pub const BINARY_DATA_FIELDS: [&str; 2] = ["data", "signature"]; #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[derive( - Default, Debug, Serialize, Deserialize, Encode, Decode, PlatformSignable, Clone, PartialEq, Eq, + Default, + Debug, + Serialize, + Deserialize, + Encode, + Decode, + PlatformSignable, + Clone, + PartialEq, + Eq, + DecodeUntrusted, )] #[serde(rename_all = "camelCase")] pub struct IdentityPublicKeyInCreationV0 { diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/mod.rs index 0e11c927edb..4899966c8b8 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/mod.rs @@ -21,9 +21,11 @@ use crate::serialization::ValueConvertible; use crate::shielded::SerializedAction; use crate::util::hash::hash_double; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_value::Identifier; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] @@ -34,12 +36,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -263,7 +267,7 @@ pub(crate) mod json_convertible_tests { #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::shielded::SerializedAction; fn mk_action(nullifier_byte: u8) -> SerializedAction { @@ -327,8 +331,9 @@ mod tests { .into(); let bytes = transition.serialize_to_bytes().expect("serialize"); - let restored = IdentityCreateFromShieldedPoolTransition::deserialize_from_bytes(&bytes) - .expect("deserialize"); + let restored = + IdentityCreateFromShieldedPoolTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("deserialize"); assert_eq!(transition, restored); } } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/v0/mod.rs index 59df7169e2c..626f67c544e 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_create_from_shielded_pool_transition/v0/mod.rs @@ -11,14 +11,14 @@ use crate::shielded::SerializedAction; use crate::state_transition::public_key_in_creation::IdentityPublicKeyInCreation; use crate::state_transition::public_key_in_creation::IdentityPublicKeyInCreationSignable; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_serialization_derive::PlatformSignable; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, PlatformSignable, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/mod.rs index a15eed53493..5c65f7e9dc4 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/mod.rs @@ -18,9 +18,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -37,12 +39,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/v0/mod.rs index 9e3c39115b8..f9ac0347706 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/identity_top_up_from_shielded_pool_transition/v0/mod.rs @@ -7,8 +7,10 @@ mod version; use crate::prelude::Identifier; use crate::shielded::SerializedAction; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -24,9 +26,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -53,17 +57,19 @@ pub struct IdentityTopUpFromShieldedPoolTransitionV0 { #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/mod.rs index 541deac47fa..67fff81eaad 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/mod.rs @@ -27,9 +27,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -39,12 +41,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/v0/mod.rs index 7a4e185b618..9bfc5045fef 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_asset_lock_transition/v0/mod.rs @@ -9,8 +9,10 @@ use crate::address_funds::PlatformAddress; use crate::identity::state_transition::asset_lock_proof::AssetLockProof; use crate::shielded::SerializedAction; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -22,9 +24,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -63,18 +67,20 @@ pub struct ShieldFromAssetLockTransitionV0 { mod tests { use super::*; use crate::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dashcore::OutPoint; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/mod.rs index 3a8f7d3c5f4..6fbe4208b5f 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/mod.rs @@ -20,10 +20,12 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use fields::*; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -39,12 +41,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/v0/mod.rs index 269239642de..a791e8724cc 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_from_identity_transition/v0/mod.rs @@ -12,8 +12,10 @@ use crate::prelude::{Identifier, IdentityNonce, UserFeeIncrease}; use crate::serialization::json_safe_fields; use crate::shielded::SerializedAction; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_value::BinaryData; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -30,9 +32,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr(feature = "json-conversion", json_safe_fields)] #[cfg_attr( @@ -68,18 +72,20 @@ pub struct ShieldFromIdentityTransitionV0 { #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable, Signable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, Signable}; use crate::state_transition::StateTransition; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/mod.rs index d81ad112d31..123a87060bb 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/mod.rs @@ -18,9 +18,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -30,12 +32,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/v0/mod.rs index 597e4372b48..a62d94a6535 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shield_transition/v0/mod.rs @@ -12,8 +12,10 @@ use crate::fee::Credits; use crate::prelude::{AddressNonce, UserFeeIncrease}; use crate::shielded::SerializedAction; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -24,9 +26,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -65,17 +69,19 @@ pub struct ShieldTransitionV0 { #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/mod.rs index 1b4943406d6..cdbb35c9557 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/mod.rs @@ -18,9 +18,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -30,12 +32,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/v0/mod.rs index 2c0cb8406be..de4c39fa423 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_transfer_transition/v0/mod.rs @@ -6,8 +6,10 @@ mod version; use crate::shielded::SerializedAction; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -18,9 +20,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -44,17 +48,19 @@ pub struct ShieldedTransferTransitionV0 { #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/mod.rs index 4cb092e86a5..c841108c06a 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/mod.rs @@ -18,9 +18,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -30,12 +32,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/v0/mod.rs index 1bc9f395e81..71b10f794c7 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/shielded_withdrawal_transition/v0/mod.rs @@ -8,8 +8,10 @@ use crate::identity::core_script::CoreScript; use crate::shielded::SerializedAction; use crate::withdrawal::Pooling; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -20,9 +22,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -56,17 +60,19 @@ pub struct ShieldedWithdrawalTransitionV0 { #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/mod.rs index 1a8f8c8085a..43fa524b1ac 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/mod.rs @@ -18,9 +18,11 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; use platform_versioning::PlatformVersioned; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -30,12 +32,14 @@ use serde::{Deserialize, Serialize}; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/v0/mod.rs b/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/v0/mod.rs index 0ee73864934..2b0dddbe446 100644 --- a/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/v0/mod.rs +++ b/packages/rs-dpp/src/state_transition/state_transitions/shielded/unshield_transition/v0/mod.rs @@ -7,8 +7,10 @@ mod version; use crate::address_funds::PlatformAddress; use crate::shielded::SerializedAction; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -19,9 +21,11 @@ use serde::{Deserialize, Serialize}; Encode, Decode, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSignable, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -48,17 +52,19 @@ pub struct UnshieldTransitionV0 { mod tests { use super::*; use crate::address_funds::PlatformAddress; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use std::fmt::Debug; - fn test_round_trip( + fn test_round_trip< + T: PlatformSerializable + PlatformDeserializableUntrusted + Debug + PartialEq, + >( transition: T, ) where ::Error: std::fmt::Debug, { let serialized = T::serialize_to_bytes(&transition).expect("expected to serialize"); - let deserialized = - T::deserialize_from_bytes(serialized.as_slice()).expect("expected to deserialize"); + let deserialized = T::deserialize_from_bytes_untrusted(serialized.as_slice()) + .expect("expected to deserialize"); assert_eq!(transition, deserialized); } diff --git a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs index a06d5bd69c7..f005be86412 100644 --- a/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs +++ b/packages/rs-dpp/src/state_transition/traits/state_transition_identity_signed.rs @@ -140,12 +140,12 @@ pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], Prot // // use super::StateTransitionIdentitySignedV0; // use super::*; -// use crate::serialization::PlatformDeserializable; +// use crate::serialization::PlatformDeserializableUntrusted; // use crate::serialization::PlatformSerializable; // use crate::serialization::Signable; // use crate::version::FeatureVersion; // use bincode::{config, Decode, Encode}; -// use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize, PlatformSignable}; +// use platform_serialization_derive::{PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, PlatformSignable}; // // #[derive( // Debug, @@ -154,7 +154,7 @@ pub fn get_compressed_public_ec_key(private_key: &[u8]) -> Result<[u8; 33], Prot // Decode, // Serialize, // Deserialize, -// PlatformDeserialize, +// PlatformDeserializeTrusted, PlatformDeserializeUntrusted, // PlatformSerialize, // PlatformSignable, // )] diff --git a/packages/rs-dpp/src/tokens/contract_info/mod.rs b/packages/rs-dpp/src/tokens/contract_info/mod.rs index ba96a52d24e..70af4cf0c3f 100644 --- a/packages/rs-dpp/src/tokens/contract_info/mod.rs +++ b/packages/rs-dpp/src/tokens/contract_info/mod.rs @@ -1,10 +1,12 @@ use crate::data_contract::TokenContractPosition; use crate::tokens::contract_info::v0::TokenContractInfoV0; use crate::ProtocolError; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use derive_more::From; use platform_serialization::de::Decode; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; @@ -17,11 +19,13 @@ pub mod v0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version #[cfg_attr( diff --git a/packages/rs-dpp/src/tokens/contract_info/v0/mod.rs b/packages/rs-dpp/src/tokens/contract_info/v0/mod.rs index f8590d7250f..74523fd96bd 100644 --- a/packages/rs-dpp/src/tokens/contract_info/v0/mod.rs +++ b/packages/rs-dpp/src/tokens/contract_info/v0/mod.rs @@ -1,9 +1,9 @@ use crate::data_contract::TokenContractPosition; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; use platform_value::Identifier; -#[derive(Debug, Clone, Encode, Decode, From, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, From, PartialEq, DecodeUntrusted)] #[cfg_attr( any(feature = "fixtures-and-mocks", feature = "serde-conversion"), derive(serde::Serialize, serde::Deserialize), diff --git a/packages/rs-dpp/src/tokens/emergency_action.rs b/packages/rs-dpp/src/tokens/emergency_action.rs index 89e03f8a1b4..d7cfa758edf 100644 --- a/packages/rs-dpp/src/tokens/emergency_action.rs +++ b/packages/rs-dpp/src/tokens/emergency_action.rs @@ -1,11 +1,13 @@ use crate::tokens::status::TokenStatus; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_version::version::PlatformVersion; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Copy, Default, Encode, Decode, PartialOrd, PartialEq, Eq)] +#[derive( + Debug, Clone, Copy, Default, Encode, Decode, PartialOrd, PartialEq, Eq, DecodeUntrusted, +)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/tokens/gas_fees_paid_by.rs b/packages/rs-dpp/src/tokens/gas_fees_paid_by.rs index e7987805a14..06087f96ae5 100644 --- a/packages/rs-dpp/src/tokens/gas_fees_paid_by.rs +++ b/packages/rs-dpp/src/tokens/gas_fees_paid_by.rs @@ -2,12 +2,12 @@ use crate::consensus::basic::data_contract::UnknownGasFeesPaidByError; use crate::consensus::basic::BasicError; use crate::consensus::ConsensusError; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Copy, Encode, Decode, Default, PartialEq, Display)] +#[derive(Debug, Clone, Copy, Encode, Decode, Default, PartialEq, Display, DecodeUntrusted)] #[cfg_attr(feature = "serde-conversion", derive(Serialize, Deserialize))] pub enum GasFeesPaidBy { /// The user pays the gas fees diff --git a/packages/rs-dpp/src/tokens/info/mod.rs b/packages/rs-dpp/src/tokens/info/mod.rs index f4bf7a61528..4449cd23e02 100644 --- a/packages/rs-dpp/src/tokens/info/mod.rs +++ b/packages/rs-dpp/src/tokens/info/mod.rs @@ -7,10 +7,12 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::tokens::info::v0::IdentityTokenInfoV0; use crate::ProtocolError; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use derive_more::From; use platform_serialization::de::Decode; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; mod methods; @@ -28,11 +30,13 @@ pub mod v0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version #[cfg_attr( diff --git a/packages/rs-dpp/src/tokens/info/v0/mod.rs b/packages/rs-dpp/src/tokens/info/v0/mod.rs index 28df747105c..3443fe7694d 100644 --- a/packages/rs-dpp/src/tokens/info/v0/mod.rs +++ b/packages/rs-dpp/src/tokens/info/v0/mod.rs @@ -1,10 +1,10 @@ #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, From, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, From, PartialEq, DecodeUntrusted)] #[cfg_attr( any(feature = "fixtures-and-mocks", feature = "serde-conversion"), derive(serde::Serialize, serde::Deserialize) diff --git a/packages/rs-dpp/src/tokens/status/mod.rs b/packages/rs-dpp/src/tokens/status/mod.rs index 627352683be..f9f0b77480e 100644 --- a/packages/rs-dpp/src/tokens/status/mod.rs +++ b/packages/rs-dpp/src/tokens/status/mod.rs @@ -4,10 +4,12 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::tokens::status::v0::TokenStatusV0; use crate::ProtocolError; -use bincode::Encode; +use bincode::{DecodeUntrusted, Encode}; use derive_more::From; use platform_serialization::de::Decode; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_version::version::PlatformVersion; use platform_versioning::PlatformVersioned; mod methods; @@ -22,11 +24,13 @@ pub mod v0; Clone, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PlatformVersioned, From, PartialEq, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/tokens/status/v0/mod.rs b/packages/rs-dpp/src/tokens/status/v0/mod.rs index db76fa5e56e..2fdd46fd6d4 100644 --- a/packages/rs-dpp/src/tokens/status/v0/mod.rs +++ b/packages/rs-dpp/src/tokens/status/v0/mod.rs @@ -1,10 +1,10 @@ #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, From, PartialEq)] +#[derive(Debug, Clone, Encode, Decode, From, PartialEq, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(serde::Serialize, serde::Deserialize), diff --git a/packages/rs-dpp/src/tokens/token_event.rs b/packages/rs-dpp/src/tokens/token_event.rs index 5066b0f0479..627837f4726 100644 --- a/packages/rs-dpp/src/tokens/token_event.rs +++ b/packages/rs-dpp/src/tokens/token_event.rs @@ -14,8 +14,10 @@ use crate::prelude::{ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use platform_version::version::PlatformVersion; use std::collections::BTreeMap; @@ -58,7 +60,17 @@ pub type FrozenIdentifier = Identifier; /// involved identities, and amounts. It is **externally versioned** and marked as `unversioned` in platform serialization, /// meaning each variant is self-contained without requiring version dispatching logic. #[derive( - Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize, + Debug, + PartialEq, + PartialOrd, + Clone, + Eq, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + DecodeUntrusted, )] // Custom `Serialize` / `Deserialize` below — `TokenEvent` is a flat enum // with all-tuple variants. Internal tagging requires struct variants or diff --git a/packages/rs-dpp/src/tokens/token_payment_info/mod.rs b/packages/rs-dpp/src/tokens/token_payment_info/mod.rs index 9a37abb3777..26c00466984 100644 --- a/packages/rs-dpp/src/tokens/token_payment_info/mod.rs +++ b/packages/rs-dpp/src/tokens/token_payment_info/mod.rs @@ -49,9 +49,11 @@ use crate::tokens::token_payment_info::methods::v0::TokenPaymentInfoMethodsV0; use crate::tokens::token_payment_info::v0::v0_accessors::TokenPaymentInfoAccessorsV0; use crate::tokens::token_payment_info::v0::TokenPaymentInfoV0; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::{Display, From}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::btreemap_extensions::BTreeValueMapHelper; #[cfg(feature = "value-conversion")] use platform_value::Error; @@ -69,11 +71,13 @@ pub mod v0; Copy, Encode, Decode, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, PlatformSerialize, PartialEq, Display, From, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/tokens/token_payment_info/v0/mod.rs b/packages/rs-dpp/src/tokens/token_payment_info/v0/mod.rs index b180bbbf9b0..8934aed3097 100644 --- a/packages/rs-dpp/src/tokens/token_payment_info/v0/mod.rs +++ b/packages/rs-dpp/src/tokens/token_payment_info/v0/mod.rs @@ -5,7 +5,7 @@ use crate::data_contract::TokenContractPosition; use crate::tokens::gas_fees_paid_by::GasFeesPaidBy; use crate::tokens::token_payment_info::v0::v0_accessors::TokenPaymentInfoAccessorsV0; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::Display; use platform_value::btreemap_extensions::BTreeValueRemoveFromMapHelper; use platform_value::{Identifier, Value}; @@ -13,7 +13,7 @@ use platform_value::{Identifier, Value}; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; -#[derive(Debug, Clone, Copy, Encode, Decode, Default, PartialEq, Display)] +#[derive(Debug, Clone, Copy, Encode, Decode, Default, PartialEq, Display, DecodeUntrusted)] // `json_safe_fields` auto-injects `json_safe_option_u64` on // `Option` (= `Option`) fields so JSON encodes large // values as strings — same convention as the rest of the wire shape. diff --git a/packages/rs-dpp/src/tokens/token_pricing_schedule.rs b/packages/rs-dpp/src/tokens/token_pricing_schedule.rs index b73b0ab5251..9d1c3a608c6 100644 --- a/packages/rs-dpp/src/tokens/token_pricing_schedule.rs +++ b/packages/rs-dpp/src/tokens/token_pricing_schedule.rs @@ -1,8 +1,10 @@ use crate::balances::credits::TokenAmount; use crate::errors::ProtocolError; use crate::fee::Credits; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; @@ -23,7 +25,9 @@ use std::fmt::{self, Display, Formatter}; Ord, PartialOrd, PlatformSerialize, - PlatformDeserialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", diff --git a/packages/rs-dpp/src/voting/contender_structs/contender/mod.rs b/packages/rs-dpp/src/voting/contender_structs/contender/mod.rs index a8e4e9c42d7..2e2366775cc 100644 --- a/packages/rs-dpp/src/voting/contender_structs/contender/mod.rs +++ b/packages/rs-dpp/src/voting/contender_structs/contender/mod.rs @@ -7,13 +7,15 @@ use crate::document::Document; use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use crate::serialization::{PlatformDeserializable, PlatformSerializable}; +use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use crate::voting::contender_structs::contender::v0::ContenderV0; use crate::voting::contender_structs::ContenderWithSerializedDocumentV0; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use platform_version::version::PlatformVersion; @@ -37,7 +39,17 @@ pub enum Contender { derive(JsonConvertible) )] #[derive( - Debug, PartialEq, Eq, Clone, From, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Debug, + PartialEq, + Eq, + Clone, + From, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[cfg_attr( feature = "serde-conversion", @@ -214,7 +226,9 @@ impl Contender { Self: Sized, { let serialized_contender = - ContenderWithSerializedDocument::deserialize_from_bytes(serialized_contender)?; + ContenderWithSerializedDocument::deserialize_from_bytes_untrusted( + serialized_contender, + )?; serialized_contender.try_into_contender(document_type, platform_version) } } @@ -379,8 +393,9 @@ mod tests { assert!(!bytes.is_empty()); // Deserialize back - let restored = ContenderWithSerializedDocument::deserialize_from_bytes(&bytes) - .expect("should deserialize from bytes"); + let restored = + ContenderWithSerializedDocument::deserialize_from_bytes_untrusted(&bytes) + .expect("should deserialize from bytes"); assert_eq!(wrapped, restored); } @@ -398,8 +413,9 @@ mod tests { let bytes = wrapped .serialize_to_bytes() .expect("should serialize to bytes"); - let restored = ContenderWithSerializedDocument::deserialize_from_bytes(&bytes) - .expect("should deserialize from bytes"); + let restored = + ContenderWithSerializedDocument::deserialize_from_bytes_untrusted(&bytes) + .expect("should deserialize from bytes"); assert_eq!(wrapped, restored); } diff --git a/packages/rs-dpp/src/voting/contender_structs/contender/v0/mod.rs b/packages/rs-dpp/src/voting/contender_structs/contender/v0/mod.rs index bc218d18085..b265e9f392f 100644 --- a/packages/rs-dpp/src/voting/contender_structs/contender/v0/mod.rs +++ b/packages/rs-dpp/src/voting/contender_structs/contender/v0/mod.rs @@ -5,7 +5,7 @@ use crate::document::Document; #[cfg(feature = "json-conversion")] use crate::serialization::json_safe_fields; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use platform_version::version::PlatformVersion; @@ -29,7 +29,7 @@ pub struct ContenderV0 { /// This struct holds the identity ID of the contender, the serialized document, /// and the vote tally. #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(serde::Serialize, serde::Deserialize), diff --git a/packages/rs-dpp/src/voting/contender_structs/mod.rs b/packages/rs-dpp/src/voting/contender_structs/mod.rs index bab08840e1a..5e25b9d4163 100644 --- a/packages/rs-dpp/src/voting/contender_structs/mod.rs +++ b/packages/rs-dpp/src/voting/contender_structs/mod.rs @@ -5,7 +5,7 @@ use crate::document::serialization_traits::DocumentPlatformConversionMethodsV0; use crate::document::Document; use crate::voting::vote_choices::resource_vote_choice::ResourceVoteChoice; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use platform_version::version::PlatformVersion; use std::fmt; @@ -33,7 +33,7 @@ pub struct FinalizedContenderWithSerializedDocument { /// /// This struct holds the identity ID of the contender, the serialized document, /// and the vote tally. -#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode, DecodeUntrusted)] pub struct FinalizedResourceVoteChoicesWithVoterInfo { /// The resource vote choice. pub resource_vote_choice: ResourceVoteChoice, diff --git a/packages/rs-dpp/src/voting/vote_choices/resource_vote_choice/mod.rs b/packages/rs-dpp/src/voting/vote_choices/resource_vote_choice/mod.rs index 9373a007d76..82184dec4e4 100644 --- a/packages/rs-dpp/src/voting/vote_choices/resource_vote_choice/mod.rs +++ b/packages/rs-dpp/src/voting/vote_choices/resource_vote_choice/mod.rs @@ -6,7 +6,7 @@ use crate::voting::vote_choices::resource_vote_choice::ResourceVoteChoice::{ Abstain, Lock, TowardsIdentity, }; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -21,7 +21,9 @@ use std::fmt; /// In this case Malaka might have a bad connotation in Greek, hence some might votes to Lock /// the name. /// -#[derive(Debug, Clone, Copy, Encode, Decode, Ord, Eq, PartialOrd, PartialEq, Default)] +#[derive( + Debug, Clone, Copy, Encode, Decode, Ord, Eq, PartialOrd, PartialEq, Default, DecodeUntrusted, +)] // Custom `Serialize` / `Deserialize` below — `derive(Serialize, Deserialize)` // can't produce the desired flat wire shape because the `TowardsIdentity` // variant wraps `Identifier` (a tuple struct that serializes as a base58 diff --git a/packages/rs-dpp/src/voting/vote_choices/yes_no_abstain_vote_choice/mod.rs b/packages/rs-dpp/src/voting/vote_choices/yes_no_abstain_vote_choice/mod.rs index 03bcdf65786..78af1ddccee 100644 --- a/packages/rs-dpp/src/voting/vote_choices/yes_no_abstain_vote_choice/mod.rs +++ b/packages/rs-dpp/src/voting/vote_choices/yes_no_abstain_vote_choice/mod.rs @@ -1,8 +1,8 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Copy, Encode, Decode, PartialEq, Default)] +#[derive(Debug, Clone, Copy, Encode, Decode, PartialEq, Default, DecodeUntrusted)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/mod.rs b/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/mod.rs index 8ccd89cac11..c99196e9b57 100644 --- a/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/mod.rs +++ b/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/mod.rs @@ -7,9 +7,11 @@ use crate::voting::contender_structs::{ use crate::voting::vote_info_storage::contested_document_vote_poll_stored_info::v0::ContestedDocumentVotePollStoredInfoV0; use crate::voting::vote_info_storage::contested_document_vote_poll_winner_info::ContestedDocumentVotePollWinnerInfo; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; use platform_version::version::PlatformVersion; use std::fmt; @@ -17,7 +19,7 @@ pub use v0::ContestedDocumentVotePollStoredInfoV0Getters; pub type LockedVotePollCounter = u16; -#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Encode, Decode, DecodeUntrusted)] pub enum ContestedDocumentVotePollStatus { #[default] NotStarted, @@ -54,7 +56,17 @@ impl ContestedDocumentVotePollStatus { /// /// This struct holds the list of contenders, the abstaining vote tally. #[derive( - Debug, PartialEq, Eq, Clone, From, Encode, Decode, PlatformSerialize, PlatformDeserialize, + Debug, + PartialEq, + Eq, + Clone, + From, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + DecodeUntrusted, )] #[platform_serialize(unversioned)] pub enum ContestedDocumentVotePollStoredInfo { @@ -210,7 +222,7 @@ impl ContestedDocumentVotePollStoredInfoV0Getters for ContestedDocumentVotePollS #[cfg(test)] mod tests { use super::*; - use crate::serialization::{PlatformDeserializable, PlatformSerializable}; + use crate::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; fn sb(time: u64, height: u64) -> BlockInfo { BlockInfo { @@ -277,8 +289,9 @@ mod tests { let pv = PlatformVersion::latest(); let info = ContestedDocumentVotePollStoredInfo::new(sb(1, 1), pv).unwrap(); let bytes = info.serialize_to_bytes().expect("serialize"); - let restored = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes(&bytes) - .expect("deserialize"); + let restored = + ContestedDocumentVotePollStoredInfo::deserialize_from_bytes_untrusted(&bytes) + .expect("deserialize"); assert_eq!(info, restored); } diff --git a/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/v0/mod.rs b/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/v0/mod.rs index 960d1ca15a1..d890f2781bf 100644 --- a/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/v0/mod.rs +++ b/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_stored_info/v0/mod.rs @@ -7,12 +7,12 @@ use crate::voting::vote_choices::resource_vote_choice::ResourceVoteChoice; use crate::voting::vote_info_storage::contested_document_vote_poll_stored_info::ContestedDocumentVotePollStatus; use crate::voting::vote_info_storage::contested_document_vote_poll_winner_info::ContestedDocumentVotePollWinnerInfo; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use std::fmt; // We can have multiple rounds of voting, after an unlock for example -#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode, DecodeUntrusted)] pub struct ContestedDocumentVotePollStoredInfoVoteEventV0 { /// The list of contenders returned by the query. pub resource_vote_choices: Vec, @@ -42,7 +42,7 @@ impl fmt::Display for ContestedDocumentVotePollStoredInfoVoteEventV0 { } } -#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Default, Encode, Decode, DecodeUntrusted)] pub struct ContestedDocumentVotePollStoredInfoV0 { /// The list of contenders returned by the query. pub finalized_events: Vec, diff --git a/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_winner_info/mod.rs b/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_winner_info/mod.rs index 79825f00e0a..ca9f59fdc2d 100644 --- a/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_winner_info/mod.rs +++ b/packages/rs-dpp/src/voting/vote_info_storage/contested_document_vote_poll_winner_info/mod.rs @@ -2,12 +2,12 @@ use crate::serialization::JsonConvertible; #[cfg(feature = "value-conversion")] use crate::serialization::ValueConvertible; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use platform_value::Identifier; use serde::{Deserialize, Serialize}; use std::fmt; -#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Encode, Decode, DecodeUntrusted)] // Custom `Serialize` / `Deserialize` below — same pattern as // `ResourceVoteChoice`. The `WonByIdentity` variant wraps `Identifier` // (a tuple struct that serializes as a base58 string, not a map), so diff --git a/packages/rs-dpp/src/voting/vote_polls/contested_document_resource_vote_poll/mod.rs b/packages/rs-dpp/src/voting/vote_polls/contested_document_resource_vote_poll/mod.rs index 7047493cd93..675d7f18f78 100644 --- a/packages/rs-dpp/src/voting/vote_polls/contested_document_resource_vote_poll/mod.rs +++ b/packages/rs-dpp/src/voting/vote_polls/contested_document_resource_vote_poll/mod.rs @@ -7,8 +7,10 @@ use crate::serialization::PlatformSerializable; use crate::serialization::ValueConvertible; use crate::util::hash::hash_double; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::{Identifier, Value}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -19,7 +21,17 @@ use std::fmt; all(feature = "json-conversion", feature = "serde-conversion"), derive(JsonConvertible) )] -#[derive(Debug, Clone, Encode, Decode, PlatformSerialize, PlatformDeserialize, PartialEq)] +#[derive( + Debug, + Clone, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PartialEq, + DecodeUntrusted, +)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/voting/vote_polls/mod.rs b/packages/rs-dpp/src/voting/vote_polls/mod.rs index 467a283e749..8664016e4e5 100644 --- a/packages/rs-dpp/src/voting/vote_polls/mod.rs +++ b/packages/rs-dpp/src/voting/vote_polls/mod.rs @@ -4,9 +4,11 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -18,7 +20,18 @@ pub mod contested_document_resource_vote_poll; all(feature = "json-conversion", feature = "serde-conversion"), derive(JsonConvertible) )] -#[derive(Debug, Clone, Encode, Decode, PlatformSerialize, PlatformDeserialize, PartialEq, From)] +#[derive( + Debug, + Clone, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PartialEq, + From, + DecodeUntrusted, +)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/voting/votes/mod.rs b/packages/rs-dpp/src/voting/votes/mod.rs index 9e4d42327be..4b19cd9757b 100644 --- a/packages/rs-dpp/src/voting/votes/mod.rs +++ b/packages/rs-dpp/src/voting/votes/mod.rs @@ -7,14 +7,27 @@ use crate::serialization::ValueConvertible; use crate::voting::votes::resource_vote::accessors::v0::ResourceVoteGettersV0; use crate::voting::votes::resource_vote::ResourceVote; use crate::ProtocolError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use derive_more::From; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, Encode, Decode, PlatformSerialize, PlatformDeserialize, PartialEq, From)] +#[derive( + Debug, + Clone, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PartialEq, + From, + DecodeUntrusted, +)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/voting/votes/resource_vote/mod.rs b/packages/rs-dpp/src/voting/votes/resource_vote/mod.rs index ff57370eb67..6084c04e5ba 100644 --- a/packages/rs-dpp/src/voting/votes/resource_vote/mod.rs +++ b/packages/rs-dpp/src/voting/votes/resource_vote/mod.rs @@ -4,8 +4,10 @@ use crate::serialization::JsonConvertible; use crate::serialization::ValueConvertible; use crate::voting::votes::resource_vote::v0::ResourceVoteV0; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; @@ -16,7 +18,17 @@ pub mod v0; all(feature = "json-conversion", feature = "serde-conversion"), derive(JsonConvertible) )] -#[derive(Debug, Clone, Encode, Decode, PlatformSerialize, PlatformDeserialize, PartialEq)] +#[derive( + Debug, + Clone, + Encode, + Decode, + PlatformSerialize, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PartialEq, + DecodeUntrusted, +)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/voting/votes/resource_vote/v0/mod.rs b/packages/rs-dpp/src/voting/votes/resource_vote/v0/mod.rs index 7321ef5fb4a..d1253100944 100644 --- a/packages/rs-dpp/src/voting/votes/resource_vote/v0/mod.rs +++ b/packages/rs-dpp/src/voting/votes/resource_vote/v0/mod.rs @@ -3,14 +3,26 @@ use crate::serialization::json_safe_fields; use crate::voting::vote_choices::resource_vote_choice::ResourceVoteChoice; use crate::voting::vote_polls::VotePoll; use crate::ProtocolError; -use bincode::{Decode, Encode}; -use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}; +use bincode::{Decode, DecodeUntrusted, Encode}; +use platform_serialization_derive::{ + PlatformDeserializeTrusted, PlatformDeserializeUntrusted, PlatformSerialize, +}; use platform_value::Identifier; #[cfg(feature = "serde-conversion")] use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "json-conversion", json_safe_fields)] -#[derive(Debug, Clone, Encode, Decode, PlatformDeserialize, PlatformSerialize, PartialEq)] +#[derive( + Debug, + Clone, + Encode, + Decode, + PlatformDeserializeTrusted, + PlatformDeserializeUntrusted, + PlatformSerialize, + PartialEq, + DecodeUntrusted, +)] #[cfg_attr( feature = "serde-conversion", derive(Serialize, Deserialize), diff --git a/packages/rs-dpp/src/withdrawal/mod.rs b/packages/rs-dpp/src/withdrawal/mod.rs index 2c64ff1cbed..7ecd533d241 100644 --- a/packages/rs-dpp/src/withdrawal/mod.rs +++ b/packages/rs-dpp/src/withdrawal/mod.rs @@ -2,7 +2,7 @@ pub mod daily_withdrawal_limit; #[cfg(all(feature = "withdrawals-contract", feature = "system_contracts"))] mod document_try_into_asset_unlock_base_transaction_info; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde_repr::{Deserialize_repr, Serialize_repr}; #[cfg(feature = "json-conversion")] @@ -12,7 +12,17 @@ use crate::serialization::ValueConvertible; #[repr(u8)] #[derive( - Serialize_repr, Deserialize_repr, PartialEq, Eq, Clone, Copy, Debug, Encode, Decode, Default, + Serialize_repr, + Deserialize_repr, + PartialEq, + Eq, + Clone, + Copy, + Debug, + Encode, + Decode, + Default, + DecodeUntrusted, )] pub enum Pooling { #[default] diff --git a/packages/rs-dpp/tests/untrusted_decode.rs b/packages/rs-dpp/tests/untrusted_decode.rs new file mode 100644 index 00000000000..c48163447fd --- /dev/null +++ b/packages/rs-dpp/tests/untrusted_decode.rs @@ -0,0 +1,134 @@ +use bincode::config; +use dpp::address_funds::AddressWitness; +use dpp::identity::core_script::CoreScript; +use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof; +use dpp::prelude::AssetLockProof; +use dpp::serialization::PlatformDeserializableUntrusted; +use dpp::state_transition::StateTransition; + +// The derive's default crate path mirrors its in-crate DPP use. +mod serialization { + pub use dpp::serialization::PlatformDeserializableTrusted; +} +use dpp::ProtocolError; + +#[derive( + bincode::Encode, bincode::Decode, platform_serialization_derive::PlatformDeserializeTrusted, +)] +#[platform_serialize(unversioned)] +struct LocalFixture(Vec); + +/// A type that only ever decodes bytes it wrote itself derives the trusted +/// side alone and needs no `DecodeUntrusted` on its graph. +#[test] +fn should_allow_trusted_only_fixtures_without_untrusted_traits() { + use dpp::serialization::PlatformDeserializableTrusted; + + let bytes = bincode::encode_to_vec( + LocalFixture(vec![1, 2, 3]), + config::standard().with_big_endian(), + ) + .unwrap(); + assert_eq!( + LocalFixture::deserialize_from_bytes_trusted(&bytes) + .unwrap() + .0, + [1, 2, 3] + ); +} + +#[test] +fn should_reject_missing_script_in_unlimited_state_transition_decoder() { + let config = config::standard().with_big_endian(); + // IdentityCreditWithdrawal V0, through the first allocating field. + let mut bytes = + bincode::encode_to_vec((5u32, 0u32, [0u8; 32], 1_000u64, 1u32, 0u32), config).unwrap(); + bytes.extend(bincode::encode_to_vec(u64::MAX, config).unwrap()); + assert!(StateTransition::deserialize_from_bytes_untrusted_no_limit(&bytes).is_err()); + assert!(StateTransition::deserialize_from_bytes_untrusted(&bytes).is_err()); +} + +#[test] +fn should_decode_binary_scripts_with_owned_and_borrowed_untrusted_apis() { + // Include embedded NULs and cross the old custom borrowed decoder's chunk + // size. Both untrusted APIs must preserve the length-prefixed wire format. + let script = CoreScript::from_bytes(vec![0; 1_025]); + let config = config::standard().with_big_endian(); + let bytes = bincode::encode_to_vec(&script, config).unwrap(); + let ordinary = bincode::decode_from_slice::(&bytes, config).unwrap(); + let guarded = bincode::decode_from_slice_untrusted::(&bytes, config).unwrap(); + let borrowed = + bincode::borrow_decode_from_slice_untrusted::(&bytes, config).unwrap(); + assert_eq!(ordinary, (script, bytes.len())); + assert_eq!(guarded, ordinary); + assert_eq!(borrowed, ordinary); +} + +#[test] +fn should_preserve_witness_wire_format_and_signature_count_validation() { + let config = config::standard(); + let witness = AddressWitness::P2sh { + signatures: vec![vec![1; 65].into()], + redeem_script: vec![0, 1, 0, 2].into(), + }; + let bytes = bincode::encode_to_vec(&witness, config).unwrap(); + let decoded = + bincode::decode_from_slice_untrusted::(&bytes, config).unwrap(); + assert_eq!(decoded, (witness, bytes.len())); + + let witness = AddressWitness::P2sh { + signatures: vec![vec![1; 65].into(); 100], + redeem_script: vec![0].into(), + }; + let bytes = bincode::encode_to_vec(&witness, config).unwrap(); + let ordinary = bincode::decode_from_slice::(&bytes, config).unwrap_err(); + let guarded = + bincode::decode_from_slice_untrusted::(&bytes, config).unwrap_err(); + assert_eq!(ordinary.to_string(), guarded.to_string()); +} + +#[test] +fn should_preserve_asset_lock_serde_wire_format_and_reject_missing_payloads() { + let proof = AssetLockProof::Chain(ChainAssetLockProof { + core_chain_locked_height: 42, + out_point: dpp::dashcore::OutPoint::null(), + }); + let config = config::standard().with_big_endian(); + let bytes = bincode::encode_to_vec(&proof, config).unwrap(); + let ordinary = bincode::decode_from_slice::(&bytes, config).unwrap(); + let guarded = + bincode::decode_from_slice_untrusted::(&bytes, config).unwrap(); + assert_eq!(ordinary, (proof, bytes.len())); + assert_eq!(guarded, ordinary); + + // Instant proof, whose first raw Serde field is length-prefixed bytes. + let mut bytes = bincode::encode_to_vec(0u32, config).unwrap(); + bytes.extend(bincode::encode_to_vec(u64::MAX, config).unwrap()); + assert!(bincode::decode_from_slice_untrusted::(&bytes, config).is_err()); +} + +#[test] +fn should_preserve_foreign_txid_serde_encoding_in_consensus_errors() { + use dpp::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMismatchError; + use dpp::dashcore::hashes::Hash; + use dpp::dashcore::Txid; + + let value = IdentityAssetLockProofLockedTransactionMismatchError::new( + Txid::from_byte_array([1; 32]), + Txid::from_byte_array([2; 32]), + ); + let config = config::standard().with_big_endian(); + let bytes = bincode::encode_to_vec(&value, config).unwrap(); + let decoded = + IdentityAssetLockProofLockedTransactionMismatchError::deserialize_from_bytes_untrusted( + &bytes, + ) + .unwrap(); + assert_eq!(decoded, value); + let ordinary = bincode::decode_from_slice::< + IdentityAssetLockProofLockedTransactionMismatchError, + _, + >(&bytes, config) + .unwrap(); + assert_eq!(ordinary, (value, bytes.len())); +} diff --git a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs index 66fff033ad8..c32b8ebd7a4 100644 --- a/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/check_tx/v0/mod.rs @@ -24,7 +24,7 @@ use crate::execution::types::state_transition_container::v0::{ #[cfg(test)] use crate::execution::validation::state_transition::processor::process_state_transition; #[cfg(test)] -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; #[cfg(test)] use dpp::state_transition::StateTransition; use dpp::util::hash::hash_single; @@ -45,8 +45,8 @@ where raw_tx: Vec, transaction: &Transaction, ) -> Result { - let state_transition = - StateTransition::deserialize_from_bytes(raw_tx.as_slice()).map_err(Error::Protocol)?; + let state_transition = StateTransition::deserialize_from_bytes_untrusted(raw_tx.as_slice()) + .map_err(Error::Protocol)?; let state_read_guard = self.state.load(); @@ -370,8 +370,9 @@ mod tests { 217, 221, 43, 251, 104, 84, 78, 35, 20, 237, 188, 237, 240, 216, 62, 79, 208, 96, 149, 116, 62, 82, 187, 135, 219, ]; - let state_transitions = StateTransition::deserialize_many(std::slice::from_ref(&tx)) - .expect("expected a state transition"); + let state_transitions = + StateTransition::deserialize_many_untrusted(std::slice::from_ref(&tx)) + .expect("expected a state transition"); let state_transition = state_transitions.first().unwrap(); let StateTransition::DataContractCreate(contract_create) = state_transition else { panic!("expecting a data contract create"); diff --git a/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v0/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v0/mod.rs index 4f66d59dce8..a2f1ffe22c2 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v0/mod.rs @@ -8,7 +8,7 @@ use dpp::dashcore::hashes::Hash; use dpp::data_contracts::SystemDataContract; use dpp::fee::Credits; use dpp::platform_value::Identifier; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::system_data_contracts::load_system_data_contract; use dpp::version::PlatformVersion; use dpp::version::ProtocolVersion; @@ -306,8 +306,9 @@ impl Platform { let contested_document_resource_vote_poll_bytes = element .into_item_bytes() .map_err(drive::error::Error::from)?; - let vote_poll = - VotePoll::deserialize_from_bytes(&contested_document_resource_vote_poll_bytes)?; + let vote_poll = VotePoll::deserialize_from_bytes_trusted( + &contested_document_resource_vote_poll_bytes, + )?; match vote_poll { VotePoll::ContestedDocumentResourceVotePoll(contested) => { contested.specialized_balance_id().map_err(Error::Protocol) diff --git a/packages/rs-drive-abci/src/execution/platform_events/state_transition_processing/decode_raw_state_transitions/v0/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/state_transition_processing/decode_raw_state_transitions/v0/mod.rs index f5df41708dd..59994966c6a 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/state_transition_processing/decode_raw_state_transitions/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/state_transition_processing/decode_raw_state_transitions/v0/mod.rs @@ -72,7 +72,7 @@ where } else { let start_time = Instant::now(); - match StateTransition::deserialize_from_bytes_in_version( + match StateTransition::deserialize_from_bytes_untrusted_in_version( raw_state_transition.as_ref(), platform_version, ) { diff --git a/packages/rs-drive-abci/src/execution/storage/fetch_platform_state/v0/mod.rs b/packages/rs-drive-abci/src/execution/storage/fetch_platform_state/v0/mod.rs index a815e0266a6..d63ddda270b 100644 --- a/packages/rs-drive-abci/src/execution/storage/fetch_platform_state/v0/mod.rs +++ b/packages/rs-drive-abci/src/execution/storage/fetch_platform_state/v0/mod.rs @@ -1,7 +1,7 @@ use crate::error::Error; use crate::platform_types::platform::Platform; use crate::platform_types::platform_state::PlatformState; -use dpp::serialization::PlatformDeserializableFromVersionedStructure; +use dpp::serialization::PlatformDeserializableFromVersionedStructureTrusted; use dpp::version::PlatformVersion; use drive::drive::Drive; use drive::query::TransactionArg; @@ -16,7 +16,7 @@ impl Platform { .fetch_platform_state_bytes(transaction, platform_version) .map_err(Error::Drive)? .map(|bytes| { - let result = PlatformState::versioned_deserialize(&bytes, platform_version) + let result = PlatformState::versioned_deserialize_trusted(&bytes, platform_version) .map_err(Error::Protocol); if result.is_err() { diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs index e2ea0840ec6..5e541c984d3 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs @@ -22,7 +22,7 @@ mod tests { use dpp::identity::signer::Signer; use dpp::platform_value::BinaryData; use dpp::prelude::AddressNonce; - use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; + use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::address_credit_withdrawal_transition::methods::AddressCreditWithdrawalTransitionMethodsV0; use dpp::state_transition::address_credit_withdrawal_transition::v0::AddressCreditWithdrawalTransitionV0; use dpp::state_transition::address_credit_withdrawal_transition::AddressCreditWithdrawalTransition; @@ -4324,8 +4324,8 @@ mod tests { let serialized = transition.serialize_to_bytes().expect("should serialize"); // Deserialize - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); // Re-serialize let reserialized = deserialized @@ -4371,8 +4371,8 @@ mod tests { let serialized = transition.serialize_to_bytes().expect("should serialize"); // Should deserialize without error - let _deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let _deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); } #[tokio::test] @@ -4405,7 +4405,7 @@ mod tests { } // Should fail to deserialize or produce invalid transition - let result = StateTransition::deserialize_from_bytes(&serialized); + let result = StateTransition::deserialize_from_bytes_untrusted(&serialized); // Either deserialization fails or produces invalid data // We accept both outcomes as valid error handling if result.is_ok() { diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funds_transfer/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funds_transfer/tests.rs index 63e1a2f184e..6de743ad7f0 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funds_transfer/tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_funds_transfer/tests.rs @@ -5215,7 +5215,7 @@ mod tests { mod serialization { use super::*; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; #[tokio::test] async fn test_serialize_deserialize_roundtrip() { @@ -5241,8 +5241,8 @@ mod tests { .expect("expected to serialize"); // Deserialize - let deserialized = - StateTransition::deserialize_from_bytes(&bytes).expect("expected to deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&bytes) + .expect("expected to deserialize"); // Re-serialize and compare let bytes2 = deserialized diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/replacement.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/replacement.rs index 4df458ec9fc..3108d2d8eeb 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/replacement.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/replacement.rs @@ -1261,7 +1261,7 @@ mod replacement_tests { use crate::execution::check_tx::CheckTxLevel; use crate::execution::validation::state_transition::check_tx_verification::state_transition_to_execution_event_for_check_tx; use crate::platform_types::platform::PlatformRef; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::StateTransition; let platform_version = PlatformVersion::latest(); @@ -1447,7 +1447,7 @@ mod replacement_tests { // 4) Re-submitting identical bytes through CheckTx FirstTimeCheck must // hit the nonce check first and reject. let replayed_state_transition = - StateTransition::deserialize_from_bytes(&replace_serialized) + StateTransition::deserialize_from_bytes_untrusted(&replace_serialized) .expect("expected to deserialize replayed transition"); let platform_state = platform.state.load(); diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs index e3bd41dc828..f07845366b1 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_create_from_addresses/tests.rs @@ -26,7 +26,7 @@ mod tests { use dpp::identity::{Identity, IdentityPublicKey, IdentityV0, KeyType, Purpose, SecurityLevel}; use dpp::platform_value::BinaryData; use dpp::prelude::AddressNonce; - use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable}; + use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, Signable}; use dpp::state_transition::identity_create_from_addresses_transition::methods::IdentityCreateFromAddressesTransitionMethodsV0; use dpp::state_transition::identity_create_from_addresses_transition::v0::IdentityCreateFromAddressesTransitionV0; use dpp::state_transition::identity_create_from_addresses_transition::IdentityCreateFromAddressesTransition; @@ -4042,7 +4042,7 @@ mod tests { #[tokio::test] async fn test_transition_serializes_and_deserializes() { - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; let platform_version = PlatformVersion::latest(); let mut rng = StdRng::seed_from_u64(1100); @@ -4069,8 +4069,8 @@ mod tests { let serialized = transition.serialize_to_bytes().expect("should serialize"); // Deserialize - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); // Verify round-trip let reserialized = deserialized @@ -4084,7 +4084,7 @@ mod tests { #[tokio::test] async fn test_transition_with_output_serializes() { - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; let platform_version = PlatformVersion::latest(); let mut rng = StdRng::seed_from_u64(1101); @@ -4111,8 +4111,8 @@ mod tests { let serialized = transition.serialize_to_bytes().expect("should serialize"); - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); let reserialized = deserialized .serialize_to_bytes() @@ -4122,7 +4122,7 @@ mod tests { #[tokio::test] async fn test_transition_with_multiple_inputs_serializes() { - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; let platform_version = PlatformVersion::latest(); let mut rng = StdRng::seed_from_u64(1102); @@ -4155,8 +4155,8 @@ mod tests { let serialized = transition.serialize_to_bytes().expect("should serialize"); - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); let reserialized = deserialized .serialize_to_bytes() @@ -7550,7 +7550,7 @@ mod tests { mod serialization_roundtrip { use super::*; - use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; + use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; #[tokio::test] async fn test_full_roundtrip_serialization() { @@ -7586,8 +7586,8 @@ mod tests { .expect("should serialize"); // Deserialize - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); // Compare match deserialized { @@ -7640,8 +7640,8 @@ mod tests { let serialized = state_transition .serialize_to_bytes() .expect("should serialize"); - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); match deserialized { StateTransition::IdentityCreateFromAddresses( @@ -7697,8 +7697,8 @@ mod tests { let serialized = state_transition .serialize_to_bytes() .expect("should serialize"); - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); match deserialized { StateTransition::IdentityCreateFromAddresses( @@ -7759,8 +7759,8 @@ mod tests { let serialized = state_transition .serialize_to_bytes() .expect("should serialize"); - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); match deserialized { StateTransition::IdentityCreateFromAddresses( @@ -7777,7 +7777,7 @@ mod tests { async fn test_deserialize_invalid_bytes() { let invalid_bytes = vec![0xFF, 0xFF, 0xFF, 0xFF]; - let result = StateTransition::deserialize_from_bytes(&invalid_bytes); + let result = StateTransition::deserialize_from_bytes_untrusted(&invalid_bytes); assert!(result.is_err(), "Invalid bytes should fail deserialization"); } @@ -7815,7 +7815,7 @@ mod tests { // Truncate the data let truncated = &serialized[..serialized.len() / 2]; - let result = StateTransition::deserialize_from_bytes(truncated); + let result = StateTransition::deserialize_from_bytes_untrusted(truncated); assert!( result.is_err(), "Truncated data should fail deserialization" diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_transfer_to_addresses/tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_transfer_to_addresses/tests.rs index cacdbb9309b..3ca7055a3af 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_transfer_to_addresses/tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/identity_credit_transfer_to_addresses/tests.rs @@ -2955,7 +2955,7 @@ mod tests { mod serialization_tests { use super::*; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::identity_credit_transfer_to_addresses_transition::accessors::IdentityCreditTransferToAddressesTransitionAccessorsV0; use dpp::state_transition::StateTransitionIdentitySigned; use dpp::state_transition::StateTransitionLike; @@ -2988,8 +2988,8 @@ mod tests { .expect("should serialize"); // Deserialize - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); // Verify the deserialized transition matches the original match (&original_transition, &deserialized) { @@ -3042,8 +3042,8 @@ mod tests { let serialized = transition.serialize_to_bytes().expect("should serialize"); // Should deserialize successfully - let deserialized = - StateTransition::deserialize_from_bytes(&serialized).expect("should deserialize"); + let deserialized = StateTransition::deserialize_from_bytes_untrusted(&serialized) + .expect("should deserialize"); match deserialized { StateTransition::IdentityCreditTransferToAddresses(t) => { diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/mod.rs index 7a9e9565dc8..928edcbe02a 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/mod.rs @@ -121,7 +121,7 @@ mod tests { use crate::platform_types::platform_state::PlatformState; use crate::rpc::core::MockCoreRPCLike; use crate::test::helpers::setup::TempPlatform; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableTrusted; use drive::query::VotePollsByEndDateDriveQuery; use crate::platform_types::platform_state::PlatformStateV0Methods; use dpp::block::extended_block_info::v0::ExtendedBlockInfoV0; @@ -4120,7 +4120,7 @@ mod tests { // Let's try deserializing - let vote_poll = VotePoll::deserialize_from_bytes( + let vote_poll = VotePoll::deserialize_from_bytes_trusted( serialized_contested_vote_poll_bytes.as_slice(), ) .expect("expected to deserialize"); @@ -4377,7 +4377,7 @@ mod tests { // Let's try deserializing - let vote_poll_1 = VotePoll::deserialize_from_bytes( + let vote_poll_1 = VotePoll::deserialize_from_bytes_trusted( serialized_contested_vote_poll_bytes_1.as_slice(), ) .expect("expected to deserialize"); @@ -4403,7 +4403,7 @@ mod tests { // Let's try deserializing - let vote_poll_2 = VotePoll::deserialize_from_bytes( + let vote_poll_2 = VotePoll::deserialize_from_bytes_trusted( serialized_contested_vote_poll_bytes_2.as_slice(), ) .expect("expected to deserialize"); diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/mod.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/mod.rs index bc7356f1a3e..f0b5167375a 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/mod.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/mod.rs @@ -181,7 +181,7 @@ pub(in crate::execution) mod tests { use dpp::tokens::gas_fees_paid_by::GasFeesPaidBy; use dpp::tokens::token_amount_on_contract_token::{DocumentActionTokenCost, DocumentActionTokenEffect}; use dpp::data_contract::document_type::accessors::DocumentTypeV0MutGetters; - use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; /// We add an identity, but we also add the same amount to system credits pub(in crate::execution) fn setup_identity_with_system_credits( @@ -837,7 +837,7 @@ pub(in crate::execution) mod tests { ) -> DataContract { // Deserialize the data contract from bytes let mut data_contract = - DataContract::versioned_deserialize(&contract_bytes, false, platform_version) + DataContract::versioned_deserialize_untrusted(&contract_bytes, false, platform_version) .expect("expected to deserialize data contract"); // Get identity info based on the enum variant diff --git a/packages/rs-drive-abci/src/mimic/mod.rs b/packages/rs-drive-abci/src/mimic/mod.rs index 512faa97ff3..9434a5572b9 100644 --- a/packages/rs-drive-abci/src/mimic/mod.rs +++ b/packages/rs-drive-abci/src/mimic/mod.rs @@ -19,7 +19,7 @@ use dpp::dashcore::hashes::Hash; use dpp::platform_value::btreemap_extensions::BTreeValueMapHelper; use dpp::platform_value::string_encoding::{decode, Encoding}; use dpp::platform_value::Value; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::util::deserializer::ProtocolVersion; use dpp::version::PlatformVersion; @@ -209,7 +209,7 @@ impl FullAbciApplication<'_, C> { let serialized_error = data_map.get_bytes("serializedError").unwrap(); // Deserialize the consensus error - let error = ConsensusError::deserialize_from_bytes(&serialized_error) + let error = ConsensusError::deserialize_from_bytes_untrusted(&serialized_error) .expect("expected to deserialize consensus error"); Err(Error::Abci(AbciError::InvalidStateTransition(error))) diff --git a/packages/rs-drive-abci/src/platform_types/platform/mock.rs b/packages/rs-drive-abci/src/platform_types/platform/mock.rs index f6c01462f53..9157e2a8ff5 100644 --- a/packages/rs-drive-abci/src/platform_types/platform/mock.rs +++ b/packages/rs-drive-abci/src/platform_types/platform/mock.rs @@ -4,7 +4,7 @@ use crate::platform_types::platform::Platform; use crate::platform_types::platform_state::{PlatformState, PlatformStateV0Methods}; use crate::rpc::core::MockCoreRPCLike; use dpp::dashcore::BlockHash; -use dpp::serialization::PlatformDeserializableFromVersionedStructure; +use dpp::serialization::PlatformDeserializableFromVersionedStructureTrusted; use dpp::version::PlatformVersionCurrentVersion; use dpp::version::{PlatformVersion, ProtocolVersion}; use serde_json::json; @@ -66,7 +66,7 @@ impl Platform { if checkpoint_state_path.exists() { if let Ok(state_bytes) = std::fs::read(&checkpoint_state_path) { if let Ok(state) = - PlatformState::versioned_deserialize(&state_bytes, platform_version) + PlatformState::versioned_deserialize_trusted(&state_bytes, platform_version) { checkpoint_platform_states.insert(block_height, Arc::new(state)); } diff --git a/packages/rs-drive-abci/src/platform_types/platform/mod.rs b/packages/rs-drive-abci/src/platform_types/platform/mod.rs index 89b9eec071a..695d545b8a7 100644 --- a/packages/rs-drive-abci/src/platform_types/platform/mod.rs +++ b/packages/rs-drive-abci/src/platform_types/platform/mod.rs @@ -12,7 +12,7 @@ use crate::platform_types::check_tx_proof_verifier::CheckTxProofVerifier; use crate::platform_types::platform_state::{PlatformState, PlatformStateV0Methods}; use arc_swap::ArcSwap; use dpp::prelude::BlockHeight; -use dpp::serialization::PlatformDeserializableFromVersionedStructure; +use dpp::serialization::PlatformDeserializableFromVersionedStructureTrusted; use dpp::version::ProtocolVersion; use dpp::version::INITIAL_PROTOCOL_VERSION; use dpp::version::{PlatformVersion, PlatformVersionCurrentVersion}; @@ -187,7 +187,7 @@ impl Platform { if checkpoint_state_path.exists() { match std::fs::read(&checkpoint_state_path) { Ok(state_bytes) => { - match PlatformState::versioned_deserialize( + match PlatformState::versioned_deserialize_trusted( &state_bytes, platform_version, ) { diff --git a/packages/rs-drive-abci/src/platform_types/platform_state/mod.rs b/packages/rs-drive-abci/src/platform_types/platform_state/mod.rs index 81f438fe51a..f98ed30cd65 100644 --- a/packages/rs-drive-abci/src/platform_types/platform_state/mod.rs +++ b/packages/rs-drive-abci/src/platform_types/platform_state/mod.rs @@ -9,7 +9,9 @@ use derive_more::From; use dpp::bincode::config; use dpp::block::extended_block_info::ExtendedBlockInfo; use dpp::dashcore::{ProTxHash, QuorumHash}; -use dpp::serialization::{PlatformDeserializableFromVersionedStructure, PlatformSerializable}; +use dpp::serialization::{ + PlatformDeserializableFromVersionedStructureTrusted, PlatformSerializable, +}; use dpp::util::deserializer::ProtocolVersion; use dpp::version::{PlatformVersion, TryFromPlatformVersioned, TryIntoPlatformVersioned}; @@ -173,8 +175,8 @@ impl PlatformSerializable for PlatformState { } } -impl PlatformDeserializableFromVersionedStructure for PlatformState { - fn versioned_deserialize( +impl PlatformDeserializableFromVersionedStructureTrusted for PlatformState { + fn versioned_deserialize_trusted( data: &[u8], platform_version: &PlatformVersion, ) -> Result @@ -277,7 +279,7 @@ mod tests { let serialized_state = hex::decode(PLATFORM_STATE_V3_TESTNET.deref()).expect("failed to decode hex"); - PlatformState::versioned_deserialize(&serialized_state, &PLATFORM_V3) + PlatformState::versioned_deserialize_trusted(&serialized_state, &PLATFORM_V3) .expect("failed to deserialize state"); } @@ -286,7 +288,7 @@ mod tests { let serialized_state = hex::decode(PLATFORM_STATE_V8_DEVNET.deref()).expect("failed to decode hex"); - PlatformState::versioned_deserialize(&serialized_state, &PLATFORM_V9) + PlatformState::versioned_deserialize_trusted(&serialized_state, &PLATFORM_V9) .expect("failed to deserialize state"); } } diff --git a/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract/v0/mod.rs b/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract/v0/mod.rs index e14ea123aac..be5734efbb8 100644 --- a/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract/v0/mod.rs +++ b/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract/v0/mod.rs @@ -81,7 +81,7 @@ mod tests { use crate::query::tests::{assert_invalid_identifier, setup_platform, store_data_contract}; use dpp::dashcore::Network; use dpp::data_contract::accessors::v0::DataContractV0Getters; - use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted; use dpp::tests::fixtures::get_data_contract_fixture; #[test] @@ -230,8 +230,10 @@ mod tests { ); // Round-trip through the deserializer to prove the bytes are valid. let round_tripped = - dpp::data_contract::DataContract::versioned_deserialize(&bytes, false, version) - .expect("contract should deserialize"); + dpp::data_contract::DataContract::versioned_deserialize_trusted( + &bytes, false, version, + ) + .expect("contract should deserialize"); assert_eq!(round_tripped.id(), contract_id); } other => panic!("expected DataContract result, got {:?}", other), diff --git a/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract_history/v0/mod.rs b/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract_history/v0/mod.rs index 3fc67d45d18..395a38acdff 100644 --- a/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract_history/v0/mod.rs +++ b/packages/rs-drive-abci/src/query/data_contract_based_queries/data_contract_history/v0/mod.rs @@ -123,7 +123,7 @@ mod tests { use dpp::data_contract::schema::DataContractSchemaMethodsV0; use dpp::data_contract::DataContract; use dpp::platform_value::platform_value; - use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dpp::tests::fixtures::get_data_contract_fixture; use drive::drive::Drive; use std::sync::Arc; @@ -376,18 +376,24 @@ mod tests { assert_eq!(first_entry.date, 1000); let first_entry_data_contract = first_entry.value; - let first_data_contract_update = - DataContract::versioned_deserialize(&first_entry_data_contract, true, version) - .expect("To decode data contract"); + let first_data_contract_update = DataContract::versioned_deserialize_untrusted( + &first_entry_data_contract, + true, + version, + ) + .expect("To decode data contract"); assert_eq!(first_data_contract_update, original_data_contract); assert_eq!(second_entry.date, 2000); let second_entry_data_contract = second_entry.value; - let second_data_contract_update = - DataContract::versioned_deserialize(&second_entry_data_contract, true, version) - .expect("To decode data contract"); + let second_data_contract_update = DataContract::versioned_deserialize_untrusted( + &second_entry_data_contract, + true, + version, + ) + .expect("To decode data contract"); let updated_doc = second_data_contract_update .document_type_for_name("niceDocument") diff --git a/packages/rs-drive-abci/src/query/identity_based_queries/identities_contract_keys/v0/mod.rs b/packages/rs-drive-abci/src/query/identity_based_queries/identities_contract_keys/v0/mod.rs index fa1834c6994..77823685f2b 100644 --- a/packages/rs-drive-abci/src/query/identity_based_queries/identities_contract_keys/v0/mod.rs +++ b/packages/rs-drive-abci/src/query/identity_based_queries/identities_contract_keys/v0/mod.rs @@ -155,7 +155,7 @@ mod tests { use dpp::identity::contract_bounds::ContractBounds; use dpp::identity::{Identity, KeyID, KeyType, Purpose, SecurityLevel}; use dpp::prelude::{Identifier, IdentityPublicKey}; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use drive::util::test_helpers::test_utils::identities::create_test_identity_with_rng; use rand::prelude::StdRng; use rand::{Rng, SeedableRng}; @@ -831,9 +831,11 @@ mod tests { .filter(|key| key.purpose == purpose as i32) .fold(vec![], |mut acc, keys| { let keys = keys.keys_bytes.iter().map(|key_bytes| { - IdentityPublicKey::deserialize_from_bytes(key_bytes.as_slice()) - .unwrap() - .id() + IdentityPublicKey::deserialize_from_bytes_untrusted( + key_bytes.as_slice(), + ) + .unwrap() + .id() }); acc.extend(keys); acc @@ -1136,9 +1138,11 @@ mod tests { .filter(|key| key.purpose == purpose as i32) .fold(vec![], |mut acc, keys| { let keys = keys.keys_bytes.iter().map(|key_bytes| { - IdentityPublicKey::deserialize_from_bytes(key_bytes.as_slice()) - .unwrap() - .id() + IdentityPublicKey::deserialize_from_bytes_untrusted( + key_bytes.as_slice(), + ) + .unwrap() + .id() }); acc.extend(keys); acc diff --git a/packages/rs-drive-abci/src/query/identity_based_queries/keys/v0/mod.rs b/packages/rs-drive-abci/src/query/identity_based_queries/keys/v0/mod.rs index c73fdf34286..6f7f59a597f 100644 --- a/packages/rs-drive-abci/src/query/identity_based_queries/keys/v0/mod.rs +++ b/packages/rs-drive-abci/src/query/identity_based_queries/keys/v0/mod.rs @@ -662,7 +662,7 @@ mod tests { use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{Identity, IdentityPublicKey, KeyID}; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use drive::drive::identity::key::fetch::KeyRequestType as DriveKeyRequestType; use drive::drive::Drive; use drive::grovedb::GroveDb; @@ -723,7 +723,7 @@ mod tests { keys.keys_bytes .into_iter() .map(|bytes| { - let key = IdentityPublicKey::deserialize_from_bytes(&bytes) + let key = IdentityPublicKey::deserialize_from_bytes_untrusted(&bytes) .expect("expected a serialized identity public key"); (key.id(), key) }) @@ -772,7 +772,7 @@ mod tests { let bytes = element .into_item_bytes() .expect("key element should be an item"); - let key = IdentityPublicKey::deserialize_from_bytes(&bytes) + let key = IdentityPublicKey::deserialize_from_bytes_untrusted(&bytes) .expect("expected a serialized identity public key"); (key.id(), key) }) diff --git a/packages/rs-drive-abci/src/query/proofs/v0/mod.rs b/packages/rs-drive-abci/src/query/proofs/v0/mod.rs index 77fb7829999..838a195ce0c 100644 --- a/packages/rs-drive-abci/src/query/proofs/v0/mod.rs +++ b/packages/rs-drive-abci/src/query/proofs/v0/mod.rs @@ -4,7 +4,7 @@ use crate::platform_types::platform::Platform; use crate::platform_types::platform_state::PlatformState; use crate::query::QueryValidationResult; use dapi_grpc::drive::v0::{GetProofsRequest, GetProofsResponse}; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::StateTransition; use dpp::version::PlatformVersion; @@ -20,7 +20,7 @@ impl Platform { platform_version: &PlatformVersion, ) -> Result, Error> { let state_transition = - match StateTransition::deserialize_from_bytes(&state_transition_bytes) { + match StateTransition::deserialize_from_bytes_untrusted(&state_transition_bytes) { Ok(state_transition) => state_transition, Err(e) => { return Ok(QueryValidationResult::new_with_error(QueryError::Protocol( diff --git a/packages/rs-drive-abci/src/query/voting/decode_index_value.rs b/packages/rs-drive-abci/src/query/voting/decode_index_value.rs index 1eb03e56568..23007e05531 100644 --- a/packages/rs-drive-abci/src/query/voting/decode_index_value.rs +++ b/packages/rs-drive-abci/src/query/voting/decode_index_value.rs @@ -1,5 +1,5 @@ use crate::error::query::QueryError; -use bincode::de::{Decode, Decoder}; +use bincode::de::{DecodeUntrusted, UntrustedDecoder}; use bincode::error::DecodeError; use dpp::platform_value::Value; @@ -41,13 +41,15 @@ const MAX_INDEX_VALUE_NESTING_DEPTH: usize = 64; struct DepthLimitedValue(Value); -impl Decode<()> for DepthLimitedValue { - fn decode>(decoder: &mut D) -> Result { +impl DecodeUntrusted<()> for DepthLimitedValue { + fn decode_untrusted>( + decoder: &mut D, + ) -> Result { decode_value_at_depth(decoder, 0).map(Self) } } -fn decode_value_at_depth>( +fn decode_value_at_depth>( decoder: &mut D, depth: usize, ) -> Result { @@ -57,27 +59,27 @@ fn decode_value_at_depth>( )); } - Ok(match u32::decode(decoder)? { - 0 => Value::U128(u128::decode(decoder)?), - 1 => Value::I128(i128::decode(decoder)?), - 2 => Value::U64(u64::decode(decoder)?), - 3 => Value::I64(i64::decode(decoder)?), - 4 => Value::U32(u32::decode(decoder)?), - 5 => Value::I32(i32::decode(decoder)?), - 6 => Value::U16(u16::decode(decoder)?), - 7 => Value::I16(i16::decode(decoder)?), - 8 => Value::U8(u8::decode(decoder)?), - 9 => Value::I8(i8::decode(decoder)?), - 10 => Value::Bytes(Vec::::decode(decoder)?), - 11 => Value::Bytes20(<[u8; 20]>::decode(decoder)?), - 12 => Value::Bytes32(<[u8; 32]>::decode(decoder)?), - 13 => Value::Bytes36(<[u8; 36]>::decode(decoder)?), - 14 => Value::EnumU8(Vec::::decode(decoder)?), - 15 => Value::EnumString(Vec::::decode(decoder)?), - 16 => Value::Identifier(<[u8; 32]>::decode(decoder)?), - 17 => Value::Float(f64::decode(decoder)?), - 18 => Value::Text(String::decode(decoder)?), - 19 => Value::Bool(bool::decode(decoder)?), + Ok(match u32::decode_untrusted(decoder)? { + 0 => Value::U128(u128::decode_untrusted(decoder)?), + 1 => Value::I128(i128::decode_untrusted(decoder)?), + 2 => Value::U64(u64::decode_untrusted(decoder)?), + 3 => Value::I64(i64::decode_untrusted(decoder)?), + 4 => Value::U32(u32::decode_untrusted(decoder)?), + 5 => Value::I32(i32::decode_untrusted(decoder)?), + 6 => Value::U16(u16::decode_untrusted(decoder)?), + 7 => Value::I16(i16::decode_untrusted(decoder)?), + 8 => Value::U8(u8::decode_untrusted(decoder)?), + 9 => Value::I8(i8::decode_untrusted(decoder)?), + 10 => Value::Bytes(Vec::::decode_untrusted(decoder)?), + 11 => Value::Bytes20(<[u8; 20]>::decode_untrusted(decoder)?), + 12 => Value::Bytes32(<[u8; 32]>::decode_untrusted(decoder)?), + 13 => Value::Bytes36(<[u8; 36]>::decode_untrusted(decoder)?), + 14 => Value::EnumU8(Vec::::decode_untrusted(decoder)?), + 15 => Value::EnumString(Vec::::decode_untrusted(decoder)?), + 16 => Value::Identifier(<[u8; 32]>::decode_untrusted(decoder)?), + 17 => Value::Float(f64::decode_untrusted(decoder)?), + 18 => Value::Text(String::decode_untrusted(decoder)?), + 19 => Value::Bool(bool::decode_untrusted(decoder)?), 20 => Value::Null, 21 => Value::Array(decode_array_at_depth(decoder, depth)?), 22 => Value::Map(decode_map_at_depth(decoder, depth)?), @@ -85,35 +87,43 @@ fn decode_value_at_depth>( }) } -fn decode_array_at_depth>( +fn decode_array_at_depth>( decoder: &mut D, depth: usize, ) -> Result, DecodeError> { - let len = usize::decode(decoder)?; + let len = usize::decode_untrusted(decoder)?; decoder.claim_container_read::(len)?; - let mut values = Vec::with_capacity(len); + let mut values = Vec::new(); for _ in 0..len { decoder.unclaim_bytes_read(std::mem::size_of::()); - values.push(decode_value_at_depth(decoder, depth + 1)?); + let value = decode_value_at_depth(decoder, depth + 1)?; + values + .try_reserve(1) + .map_err(|_| DecodeError::LimitExceeded)?; + values.push(value); } Ok(values) } -fn decode_map_at_depth>( +fn decode_map_at_depth>( decoder: &mut D, depth: usize, ) -> Result, DecodeError> { - let len = usize::decode(decoder)?; + let len = usize::decode_untrusted(decoder)?; decoder.claim_container_read::<(Value, Value)>(len)?; - let mut values = Vec::with_capacity(len); + let mut values = Vec::new(); for _ in 0..len { decoder.unclaim_bytes_read(std::mem::size_of::<(Value, Value)>()); - values.push(( + let pair = ( decode_value_at_depth(decoder, depth + 1)?, decode_value_at_depth(decoder, depth + 1)?, - )); + ); + values + .try_reserve(1) + .map_err(|_| DecodeError::LimitExceeded)?; + values.push(pair); } Ok(values) } @@ -176,7 +186,8 @@ where .with_limit::(); let (DepthLimitedValue(value), consumed) = - bincode::decode_from_slice::(serialized_value, config).ok()?; + bincode::decode_from_slice_untrusted::(serialized_value, config) + .ok()?; // Reject trailing bytes so each encoded cursor value is canonical. if consumed != serialized_value.len() { diff --git a/packages/rs-drive-abci/tests/strategy_tests/query.rs b/packages/rs-drive-abci/tests/strategy_tests/query.rs index d9881724b46..a7b89ac350c 100644 --- a/packages/rs-drive-abci/tests/strategy_tests/query.rs +++ b/packages/rs-drive-abci/tests/strategy_tests/query.rs @@ -15,7 +15,7 @@ use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::identity_public_key::methods::hash::IdentityPublicKeyHashMethodsV0; use dpp::identity::{Identity, PartialIdentity}; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::validation::SimpleValidationResult; use dpp::version::PlatformVersion; use drive::drive::Drive; @@ -286,7 +286,7 @@ impl QueryStrategy { assert_eq!(identity, expected_identity); } get_identity_by_public_key_hash_response::get_identity_by_public_key_hash_response_v0::Result::Identity(data) => { - let identity_id = Identity::deserialize_from_bytes(&data) + let identity_id = Identity::deserialize_from_bytes_untrusted(&data) .expect("expected to deserialize identity").id(); assert_eq!(identity_id, expected_identity.id); diff --git a/packages/rs-drive-proof-verifier/src/from_request.rs b/packages/rs-drive-proof-verifier/src/from_request.rs index 06b07344031..30904905277 100644 --- a/packages/rs-drive-proof-verifier/src/from_request.rs +++ b/packages/rs-drive-proof-verifier/src/from_request.rs @@ -324,11 +324,10 @@ impl TryFromRequest for VotePollsByDocumentTypeQue .start_at_value_info .map(|i| { let (value, _): (Value, _) = - bincode::decode_from_slice(&i.start_value, BINCODE_CONFIG).map_err( - |e| Error::RequestError { + bincode::decode_from_slice_untrusted(&i.start_value, BINCODE_CONFIG) + .map_err(|e| Error::RequestError { error: format!("cannot decode start value: {}", e), - }, - )?; + })?; Ok::<_, Error>((value, i.start_value_included)) }) .transpose()?, @@ -454,7 +453,7 @@ fn bincode_decode_values, T: IntoIterator>( values .into_iter() .map(|v| { - dpp::bincode::decode_from_slice(v.as_ref(), BINCODE_CONFIG) + dpp::bincode::decode_from_slice_untrusted(v.as_ref(), BINCODE_CONFIG) .map_err(|e| Error::RequestError { error: format!("cannot decode value: {}", e), }) diff --git a/packages/rs-drive-proof-verifier/src/lib.rs b/packages/rs-drive-proof-verifier/src/lib.rs index 5fe9a825b64..ebc8b798157 100644 --- a/packages/rs-drive-proof-verifier/src/lib.rs +++ b/packages/rs-drive-proof-verifier/src/lib.rs @@ -102,6 +102,6 @@ pub mod from_request; /// Implementation of unproved verification pub mod unproved; -// Needed for #[derive(PlatformSerialize, PlatformDeserialize)] +// Needed for #[derive(PlatformSerialize, PlatformDeserializeTrusted, PlatformDeserializeUntrusted)] #[cfg(feature = "mocks")] use dpp::serialization; diff --git a/packages/rs-drive-proof-verifier/src/proof.rs b/packages/rs-drive-proof-verifier/src/proof.rs index e5e2a6be4d3..d659ad69851 100644 --- a/packages/rs-drive-proof-verifier/src/proof.rs +++ b/packages/rs-drive-proof-verifier/src/proof.rs @@ -80,7 +80,7 @@ use dpp::identity::identities_contract_keys::IdentitiesContractKeys; use dpp::identity::Purpose; use dpp::platform_value::{self}; use dpp::prelude::{AddressNonce, DataContract, Identifier, Identity}; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::proof_result::StateTransitionProofOutcome; use dpp::state_transition::StateTransition; use dpp::version::PlatformVersion; @@ -1501,8 +1501,10 @@ impl FromProof for StateTransitionPro // Parse response to read proof and metadata let proof = response.proof().or(Err(Error::NoProofInResult))?; - let state_transition = StateTransition::deserialize_from_bytes(&request.state_transition) - .map_err(|e| Error::ProtocolError { + let state_transition = StateTransition::deserialize_from_bytes_untrusted( + &request.state_transition, + ) + .map_err(|e| Error::ProtocolError { error: e.to_string(), })?; diff --git a/packages/rs-drive-proof-verifier/src/types.rs b/packages/rs-drive-proof-verifier/src/types.rs index c043fb674b8..3f380e3a2ff 100644 --- a/packages/rs-drive-proof-verifier/src/types.rs +++ b/packages/rs-drive-proof-verifier/src/types.rs @@ -4,6 +4,10 @@ //! like [GetIdentityBalanceRequest](dapi_grpc::platform::v0::GetIdentityBalanceRequest) which returns [`u64`]. //! In this case, the [FromProof](crate::FromProof) trait is implemented for dedicated object type //! defined in this module. +//! +//! Binary serialization under `mocks` is for locally generated fixtures. Those +//! formats explicitly retain ordinary decoding for foreign Core types; network +//! responses go through the proof verification and request conversion paths. /// Evonode status pub mod evonode_status; @@ -57,7 +61,7 @@ use { bincode::{Decode, Encode}, dpp::{version as platform_version, ProtocolError}, platform_serialization::{PlatformVersionEncode, PlatformVersionedDecode}, - platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}, + platform_serialization_derive::{PlatformDeserializeTrusted, PlatformSerialize}, }; /// A data structure that holds a set of objects of a generic type `O`, indexed by a key of type `K`. @@ -120,7 +124,7 @@ pub type DataContracts = RetrievedObjects; #[derive(Debug, Clone, PartialEq, Eq)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize,), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct AddressInfo { @@ -143,7 +147,7 @@ pub type AddressInfos = RetrievedObjects; #[derive(Default, Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize,), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct Contenders { @@ -197,7 +201,7 @@ impl FromIterator<(Identifier, Option)> for Con #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Hash, Clone, derive_more::From, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize,), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct Voter(pub Identifier); @@ -206,7 +210,7 @@ pub struct Voter(pub Identifier); #[derive(Debug, Clone, derive_more::From, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize,), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct Voters(pub BTreeSet); @@ -248,7 +252,7 @@ pub struct KeysInPath { #[derive(Debug, derive_more::From, Clone, Copy)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct TotalCreditsInPlatform(pub Credits); @@ -257,7 +261,7 @@ pub struct TotalCreditsInPlatform(pub Credits); #[derive(Debug, Clone, Copy)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct NoParamQuery; @@ -266,7 +270,7 @@ pub struct NoParamQuery; #[derive(Debug, derive_more::From, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ElementFetchRequestItem(pub Element); @@ -364,7 +368,7 @@ impl FromIterator for ContestedResources { #[derive(Debug, derive_more::From, Clone)] #[cfg_attr( feature = "mocks", - derive(PlatformSerialize, PlatformDeserialize, Encode, Decode), + derive(PlatformSerialize, PlatformDeserializeTrusted, Encode, Decode), platform_serialize(unversioned) )] pub struct ContestedVote( @@ -414,7 +418,7 @@ pub type ResourceVotesByIdentity = RetrievedObjects; /// - `Decode`: Allows the struct to be deserialized from a binary format using the `bincode` crate. /// - `PlatformSerialize`: Enables serialization of the struct using the platform-specific /// serialization format. -/// - `PlatformDeserialize`: Enables deserialization of the struct using the platform-specific +/// - `PlatformDeserializeTrusted`: Enables deserialization of the struct using the platform-specific /// deserialization format. /// - `platform_serialize(unversioned)`: Specifies that the struct should be serialized /// without including a version field in the serialized data. @@ -425,7 +429,7 @@ pub type ResourceVotesByIdentity = RetrievedObjects; #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct CurrentQuorumsInfo { @@ -447,7 +451,7 @@ pub struct CurrentQuorumsInfo { #[derive(Debug, derive_more::From, Copy, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct PrefundedSpecializedBalance(pub Credits); @@ -468,7 +472,7 @@ impl From<&PrefundedSpecializedBalance> for Credits { #[derive(Clone, Debug, Default, derive_more::From)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct VotePollsGroupedByTimestamp(pub Vec<(TimestampMillis, Vec)>); @@ -676,7 +680,7 @@ pub type TokenDirectPurchasePrices = RetrievedObjects)> #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct BlockAddressBalanceChanges { @@ -718,7 +722,7 @@ pub struct BlockAddressBalanceChanges { #[derive(Debug, Clone, Default, derive_more::From)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct RecentAddressBalanceChanges(pub Vec); @@ -734,7 +738,7 @@ impl RecentAddressBalanceChanges { #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct CompactedBlockAddressBalanceChanges { @@ -750,7 +754,7 @@ pub struct CompactedBlockAddressBalanceChanges { #[derive(Debug, Clone, Default, derive_more::From)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct RecentCompactedAddressBalanceChanges(pub Vec); @@ -801,7 +805,7 @@ impl std::ops::DerefMut for PlatformAddressTrunkState { #[derive(Debug, derive_more::From, Clone, Copy)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedPoolState(pub u64); @@ -816,7 +820,7 @@ pub struct ShieldedPoolState(pub u64); #[derive(Debug, derive_more::From, Clone, Copy)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedNotesCount(pub u64); @@ -825,7 +829,7 @@ pub struct ShieldedNotesCount(pub u64); #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedEncryptedNote { @@ -850,7 +854,7 @@ pub struct ShieldedEncryptedNote { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedEncryptedNotes { @@ -865,7 +869,7 @@ pub struct ShieldedEncryptedNotes { #[derive(Debug, Clone, Default, derive_more::From)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedAnchors(pub Vec<[u8; 32]>); @@ -874,7 +878,7 @@ pub struct ShieldedAnchors(pub Vec<[u8; 32]>); #[derive(Debug, Clone, Copy, derive_more::From)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct MostRecentShieldedAnchor(pub [u8; 32]); @@ -883,7 +887,7 @@ pub struct MostRecentShieldedAnchor(pub [u8; 32]); #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedNullifierStatus { @@ -897,7 +901,7 @@ pub struct ShieldedNullifierStatus { #[derive(Debug, Clone, Default, derive_more::From)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedNullifierStatuses(pub Vec); @@ -906,7 +910,7 @@ pub struct ShieldedNullifierStatuses(pub Vec); #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedEncryptedNotesQuery { @@ -920,7 +924,7 @@ pub struct ShieldedEncryptedNotesQuery { #[derive(Debug, Clone)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] pub struct ShieldedNullifiersQuery(pub Vec<[u8; 32]>); diff --git a/packages/rs-drive-proof-verifier/src/types/evonode_status.rs b/packages/rs-drive-proof-verifier/src/types/evonode_status.rs index b8519170b43..c0529f85762 100644 --- a/packages/rs-drive-proof-verifier/src/types/evonode_status.rs +++ b/packages/rs-drive-proof-verifier/src/types/evonode_status.rs @@ -1,4 +1,8 @@ //! Status details of EvoNode, like version, current height, etc. +//! +//! Binary serialization under `mocks` is for locally generated fixtures. Those +//! formats explicitly retain ordinary decoding for foreign Core types; network +//! responses go through the proof verification and request conversion paths. use crate::Error; use dapi_grpc::platform::v0::{ @@ -10,13 +14,13 @@ use dapi_grpc::platform::v0::{ use { bincode::{Decode, Encode}, dpp::{version as platform_version, ProtocolError}, - platform_serialization_derive::{PlatformDeserialize, PlatformSerialize}, + platform_serialization_derive::{PlatformDeserializeTrusted, PlatformSerialize}, }; #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// The status of an EvoNode. @@ -37,7 +41,7 @@ pub struct EvoNodeStatus { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Information about protocol and software components versions. @@ -50,7 +54,7 @@ pub struct Version { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Information about software components versions. @@ -65,7 +69,7 @@ pub struct Software { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Information about protocol-level versions used by the node @@ -78,7 +82,7 @@ pub struct Protocol { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Tenderdash protocol versions. @@ -92,7 +96,7 @@ pub struct TenderdashProtocol { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Drive protocol versions. @@ -107,7 +111,7 @@ pub struct DriveProtocol { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Information about current time used by the node. @@ -125,7 +129,7 @@ pub struct Time { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Evo node identification information. @@ -138,7 +142,7 @@ pub struct Node { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Layer 2 blockchain information @@ -165,7 +169,7 @@ pub struct Chain { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Node networking information. @@ -181,7 +185,7 @@ pub struct Network { #[derive(Debug, Clone, Default)] #[cfg_attr( feature = "mocks", - derive(Encode, Decode, PlatformSerialize, PlatformDeserialize), + derive(Encode, Decode, PlatformSerialize, PlatformDeserializeTrusted), platform_serialize(unversioned) )] /// Information about state synchronization progress. diff --git a/packages/rs-drive-proof-verifier/tests/vectors_identity.rs b/packages/rs-drive-proof-verifier/tests/vectors_identity.rs index 7201bf48b26..4f5682fde0a 100644 --- a/packages/rs-drive-proof-verifier/tests/vectors_identity.rs +++ b/packages/rs-drive-proof-verifier/tests/vectors_identity.rs @@ -18,7 +18,7 @@ use dapi_grpc::platform::v0::{ }; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{IdentityPublicKey, KeyID}; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use drive_proof_verifier::types::{ IdentityBalance, IdentityContractNonceFetcher, IdentityNonceFetcher, IdentityPublicKeys, }; @@ -221,7 +221,7 @@ fn identity_keys() { let expected: Vec = serialized_keys .iter() .map(|serialized| { - IdentityPublicKey::deserialize_from_bytes(&common::hex_vec(serialized)) + IdentityPublicKey::deserialize_from_bytes_untrusted(&common::hex_vec(serialized)) .expect("expected fixture key must deserialize") }) .collect(); diff --git a/packages/rs-drive/src/drive/asset_lock/fetch_asset_lock_outpoint_info/v0/mod.rs b/packages/rs-drive/src/drive/asset_lock/fetch_asset_lock_outpoint_info/v0/mod.rs index c85e0dc84d3..ecfbadedd03 100644 --- a/packages/rs-drive/src/drive/asset_lock/fetch_asset_lock_outpoint_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/asset_lock/fetch_asset_lock_outpoint_info/v0/mod.rs @@ -12,7 +12,7 @@ use dpp::version::drive_versions::DriveVersion; use dpp::asset_lock::reduced_asset_lock_value::AssetLockValue; use dpp::asset_lock::StoredAssetLockInfo; use dpp::platform_value::Bytes36; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use grovedb::{TransactionArg, TreeType}; impl Drive { @@ -88,7 +88,7 @@ impl Drive { Ok::(StoredAssetLockInfo::FullyConsumed) } else { Ok(StoredAssetLockInfo::PartiallyConsumed( - AssetLockValue::deserialize_from_bytes(item_bytes)?, + AssetLockValue::deserialize_from_bytes_trusted(item_bytes)?, )) } }) diff --git a/packages/rs-drive/src/drive/contract/apply/apply_contract_with_serialization/v0/mod.rs b/packages/rs-drive/src/drive/contract/apply/apply_contract_with_serialization/v0/mod.rs index e15e4e21522..0c916c3ec51 100644 --- a/packages/rs-drive/src/drive/contract/apply/apply_contract_with_serialization/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/apply/apply_contract_with_serialization/v0/mod.rs @@ -14,7 +14,7 @@ use dpp::platform_value::string_encoding::Encoding; use dpp::prelude::DataContract; use dpp::data_contract::accessors::v0::DataContractV0Getters; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted; use dpp::version::PlatformVersion; use grovedb::batch::KeyInfoPath; @@ -191,7 +191,7 @@ impl Drive { if already_exists { if !original_contract_stored_data.is_empty() { - let original_contract = DataContract::versioned_deserialize( + let original_contract = DataContract::versioned_deserialize_trusted( &original_contract_stored_data, false, platform_version, diff --git a/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract/v0/mod.rs b/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract/v0/mod.rs index 881e157cc63..d57b19736a6 100644 --- a/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract/v0/mod.rs @@ -8,7 +8,7 @@ use crate::fees::op::LowLevelDriveOperation::{CalculatedCostOperation, PreCalcul use crate::util::storage_flags::StorageFlags; use dpp::block::epoch::Epoch; use dpp::data_contract::DataContract; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted; use dpp::version::PlatformVersion; use grovedb::{Element, TransactionArg}; use grovedb_costs::{ @@ -78,7 +78,7 @@ impl Drive { Ok(Element::Item(stored_contract_bytes, element_flag)) => { let contract = cost_return_on_error_no_add!( cost, - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_trusted( &stored_contract_bytes, false, platform_version @@ -135,7 +135,7 @@ impl Drive { Ok(Element::Item(stored_contract_bytes, element_flag)) => { let contract = cost_return_on_error_no_add!( cost, - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_trusted( &stored_contract_bytes, false, platform_version diff --git a/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract_with_history/v0/mod.rs b/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract_with_history/v0/mod.rs index 42afb612507..99f8523044e 100644 --- a/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract_with_history/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/get_fetch/fetch_contract_with_history/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use dpp::data_contract::DataContract; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted; use dpp::version::PlatformVersion; use grovedb::query_result_type::{QueryResultElement, QueryResultType}; @@ -82,9 +82,12 @@ impl Drive { })?; match value { Element::Item(item, _flags) => { - let contract = - DataContract::versioned_deserialize(item, false, platform_version) - .map_err(Error::from)?; + let contract = DataContract::versioned_deserialize_trusted( + item, + false, + platform_version, + ) + .map_err(Error::from)?; Ok((contract_time, contract)) } _ => Err(Error::Drive(DriveError::CorruptedContractPath( diff --git a/packages/rs-drive/src/drive/contract/get_fetch/fetch_contracts/v0/mod.rs b/packages/rs-drive/src/drive/contract/get_fetch/fetch_contracts/v0/mod.rs index a266ae2747e..37ef4ecf580 100644 --- a/packages/rs-drive/src/drive/contract/get_fetch/fetch_contracts/v0/mod.rs +++ b/packages/rs-drive/src/drive/contract/get_fetch/fetch_contracts/v0/mod.rs @@ -3,7 +3,7 @@ use crate::drive::{Drive, RootTree}; use crate::error::drive::DriveError; use crate::error::Error; use dpp::data_contract::DataContract; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted; use dpp::version::PlatformVersion; use grovedb::{Element, PathQuery, Query, QueryItem, SizedQuery, TransactionArg}; use std::ops::RangeFull; @@ -96,7 +96,7 @@ impl Drive { }; let contract = - DataContract::versioned_deserialize(&stored_bytes, false, platform_version) + DataContract::versioned_deserialize_trusted(&stored_bytes, false, platform_version) .map_err(Error::from)?; contracts.push(contract); diff --git a/packages/rs-drive/src/drive/credit_pools/epochs/get_finalized_epoch_info/v0/mod.rs b/packages/rs-drive/src/drive/credit_pools/epochs/get_finalized_epoch_info/v0/mod.rs index 8a07ea3c01a..3fd44dcc480 100644 --- a/packages/rs-drive/src/drive/credit_pools/epochs/get_finalized_epoch_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/credit_pools/epochs/get_finalized_epoch_info/v0/mod.rs @@ -3,7 +3,7 @@ use crate::error::drive::DriveError; use crate::error::Error; use dpp::block::epoch::{EpochIndex, EPOCH_KEY_OFFSET}; use dpp::block::finalized_epoch_info::FinalizedEpochInfo; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::version::PlatformVersion; use grovedb::query_result_type::QueryResultType; use grovedb::TransactionArg; @@ -118,7 +118,7 @@ impl Drive { let item_bytes = element.as_item_bytes()?; - let epoch_info = FinalizedEpochInfo::deserialize_from_bytes(item_bytes)?; + let epoch_info = FinalizedEpochInfo::deserialize_from_bytes_trusted(item_bytes)?; Ok((epoch_index, epoch_info)) }) diff --git a/packages/rs-drive/src/drive/group/fetch/fetch_action_infos/v0/mod.rs b/packages/rs-drive/src/drive/group/fetch/fetch_action_infos/v0/mod.rs index edf74dbce84..3fc67557a12 100644 --- a/packages/rs-drive/src/drive/group/fetch/fetch_action_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/fetch/fetch_action_infos/v0/mod.rs @@ -7,7 +7,7 @@ use dpp::group::group_action::GroupAction; use dpp::group::group_action_status::GroupActionStatus; use dpp::identifier::Identifier; use dpp::prelude::StartAtIncluded; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::version::PlatformVersion; use grovedb::query_result_type::QueryResultType; use grovedb::Element::Item; @@ -76,7 +76,10 @@ impl Drive { let action_id = Identifier::from_bytes(last_path_component)?; match element { - Item(value, ..) => Ok((action_id, GroupAction::deserialize_from_bytes(&value)?)), + Item(value, ..) => Ok(( + action_id, + GroupAction::deserialize_from_bytes_trusted(&value)?, + )), _ => Err(Error::Drive(DriveError::CorruptedDriveState( "element should be an item representing the group action".to_string(), ))), diff --git a/packages/rs-drive/src/drive/group/fetch/fetch_active_action_info/v0/mod.rs b/packages/rs-drive/src/drive/group/fetch/fetch_active_action_info/v0/mod.rs index acb154a6790..331ace6e925 100644 --- a/packages/rs-drive/src/drive/group/fetch/fetch_active_action_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/fetch/fetch_active_action_info/v0/mod.rs @@ -7,7 +7,7 @@ use crate::util::grove_operations::QueryTarget::QueryTargetValue; use dpp::data_contract::GroupContractPosition; use dpp::group::group_action::GroupAction; use dpp::identifier::Identifier; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::version::PlatformVersion; use grovedb::{TransactionArg, TreeType}; @@ -37,7 +37,7 @@ impl Drive { &platform_version.drive, )?; - let group_action = GroupAction::deserialize_from_bytes(&value)?; + let group_action = GroupAction::deserialize_from_bytes_trusted(&value)?; Ok(group_action) } @@ -81,7 +81,7 @@ impl Drive { )?; if !approximate_without_state_for_costs { - let group_action = GroupAction::deserialize_from_bytes(&value)?; + let group_action = GroupAction::deserialize_from_bytes_trusted(&value)?; Ok(Some(group_action)) } else { diff --git a/packages/rs-drive/src/drive/group/fetch/fetch_group_info/v0/mod.rs b/packages/rs-drive/src/drive/group/fetch/fetch_group_info/v0/mod.rs index 30d483e6d3d..b47243f05b6 100644 --- a/packages/rs-drive/src/drive/group/fetch/fetch_group_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/fetch/fetch_group_info/v0/mod.rs @@ -9,7 +9,7 @@ use crate::util::grove_operations::QueryTarget::QueryTargetValue; use dpp::data_contract::group::Group; use dpp::data_contract::GroupContractPosition; use dpp::identifier::Identifier; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::version::PlatformVersion; use grovedb::batch::KeyInfoPath; use grovedb::{EstimatedLayerInformation, TransactionArg, TreeType}; @@ -35,7 +35,7 @@ impl Drive { &mut vec![], &platform_version.drive, )? - .map(|value| Group::deserialize_from_bytes(&value)) + .map(|value| Group::deserialize_from_bytes_trusted(&value)) .transpose()?; Ok(maybe_group) @@ -77,7 +77,7 @@ impl Drive { drive_operations, &platform_version.drive, )? - .map(|value| Group::deserialize_from_bytes(&value)) + .map(|value| Group::deserialize_from_bytes_trusted(&value)) .transpose()?; Ok(maybe_group) diff --git a/packages/rs-drive/src/drive/group/fetch/fetch_group_infos/v0/mod.rs b/packages/rs-drive/src/drive/group/fetch/fetch_group_infos/v0/mod.rs index f4b0119ff76..26b2256aca8 100644 --- a/packages/rs-drive/src/drive/group/fetch/fetch_group_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/group/fetch/fetch_group_infos/v0/mod.rs @@ -6,7 +6,7 @@ use dpp::data_contract::group::Group; use dpp::data_contract::GroupContractPosition; use dpp::identifier::Identifier; use dpp::prelude::StartAtIncluded; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::version::PlatformVersion; use grovedb::query_result_type::QueryResultType; use grovedb::Element::Item; @@ -78,7 +78,7 @@ impl Drive { match element { Item(value, ..) => Ok(( group_contract_position, - Group::deserialize_from_bytes(&value)?, + Group::deserialize_from_bytes_trusted(&value)?, )), _ => Err(Error::Drive(DriveError::CorruptedDriveState( "token tree for infos should contain only items".to_string(), diff --git a/packages/rs-drive/src/drive/group/mod.rs b/packages/rs-drive/src/drive/group/mod.rs index c6dbaa4589f..04aaadcd156 100644 --- a/packages/rs-drive/src/drive/group/mod.rs +++ b/packages/rs-drive/src/drive/group/mod.rs @@ -32,7 +32,7 @@ mod tests { use dpp::identifier::Identifier; use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::Identity; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::token_event::TokenEvent; use dpp::version::PlatformVersion; use std::collections::BTreeMap; @@ -522,7 +522,7 @@ mod tests { .fetch_action_id_info_keep_serialized(contract_id, 0, action_id, None, platform_version) .expect("expected to fetch serialized action info"); - let deserialized = GroupAction::deserialize_from_bytes(&serialized) + let deserialized = GroupAction::deserialize_from_bytes_trusted(&serialized) .expect("expected to deserialize action info"); let expected = GroupAction::V0(GroupActionV0 { diff --git a/packages/rs-drive/src/drive/identity/key/fetch/mod.rs b/packages/rs-drive/src/drive/identity/key/fetch/mod.rs index e428554e8ce..73c8ef819f1 100644 --- a/packages/rs-drive/src/drive/identity/key/fetch/mod.rs +++ b/packages/rs-drive/src/drive/identity/key/fetch/mod.rs @@ -29,7 +29,7 @@ use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV use { crate::error::{drive::DriveError, fee::FeeError, identity::IdentityError, Error}, dpp::{ - fee::Credits, identity::IdentityPublicKey, serialization::PlatformDeserializable, + fee::Credits, identity::IdentityPublicKey, serialization::PlatformDeserializableTrusted, version::PlatformVersion, }, grovedb::{ @@ -179,7 +179,7 @@ fn element_to_identity_public_key(element: Element) -> Result Ok(Some(TokenContractInfo::deserialize_from_bytes( + Ok(Some(Item(info, _))) => Ok(Some(TokenContractInfo::deserialize_from_bytes_trusted( info.as_slice(), )?)), diff --git a/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_token_direct_purchase_price/v0/mod.rs b/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_token_direct_purchase_price/v0/mod.rs index f2cb4699445..6f615320b71 100644 --- a/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_token_direct_purchase_price/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_token_direct_purchase_price/v0/mod.rs @@ -5,7 +5,7 @@ use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; use crate::util::grove_operations::DirectQueryType; use crate::util::grove_operations::QueryTarget::QueryTargetValue; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -54,9 +54,9 @@ impl Drive { drive_operations, &platform_version.drive, ) { - Ok(Some(Item(info, _))) => Ok(Some(TokenPricingSchedule::deserialize_from_bytes( - info.as_slice(), - )?)), + Ok(Some(Item(info, _))) => Ok(Some( + TokenPricingSchedule::deserialize_from_bytes_trusted(info.as_slice())?, + )), Ok(None) => Ok(None), Err(Error::GroveDB(e)) if matches!(e.as_ref(), grovedb::Error::PathKeyNotFound(_)) => { diff --git a/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_tokens_direct_purchase_price/v0/mod.rs b/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_tokens_direct_purchase_price/v0/mod.rs index 0eff0ffeb06..900c229fdea 100644 --- a/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_tokens_direct_purchase_price/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/direct_purchase/fetch_tokens_direct_purchase_price/v0/mod.rs @@ -2,7 +2,7 @@ use crate::drive::Drive; use crate::error::drive::DriveError; use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -50,7 +50,9 @@ impl Drive { match element { Some(Item(value, ..)) => Ok(( token_id, - Some(TokenPricingSchedule::deserialize_from_bytes(&value)?), + Some(TokenPricingSchedule::deserialize_from_bytes_trusted( + &value, + )?), )), None => Ok((token_id, None)), _ => Err(Error::Drive(DriveError::CorruptedDriveState( diff --git a/packages/rs-drive/src/drive/tokens/freeze/v0/mod.rs b/packages/rs-drive/src/drive/tokens/freeze/v0/mod.rs index e36c6120776..7565ae8149a 100644 --- a/packages/rs-drive/src/drive/tokens/freeze/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/freeze/v0/mod.rs @@ -7,7 +7,7 @@ use crate::util::grove_operations::QueryTarget::QueryTargetValue; use dpp::block::block_info::BlockInfo; use dpp::fee::fee_result::FeeResult; use dpp::identifier::Identifier; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableTrusted, PlatformSerializable}; use dpp::tokens::info::v0::IdentityTokenInfoV0Accessors; use dpp::tokens::info::IdentityTokenInfo; use dpp::version::PlatformVersion; @@ -115,7 +115,7 @@ impl Drive { &mut drive_operations, &platform_version.drive, )? - .map(|bytes| IdentityTokenInfo::deserialize_from_bytes(&bytes)) + .map(|bytes| IdentityTokenInfo::deserialize_from_bytes_trusted(&bytes)) .transpose()? { None => { diff --git a/packages/rs-drive/src/drive/tokens/info/fetch_identities_token_infos/v0/mod.rs b/packages/rs-drive/src/drive/tokens/info/fetch_identities_token_infos/v0/mod.rs index 4f689d29f8b..7cad0dfb5a2 100644 --- a/packages/rs-drive/src/drive/tokens/info/fetch_identities_token_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/info/fetch_identities_token_infos/v0/mod.rs @@ -2,7 +2,7 @@ use crate::drive::Drive; use crate::error::drive::DriveError; use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::info::IdentityTokenInfo; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -53,7 +53,7 @@ impl Drive { match element { Some(Item(value, ..)) => Ok(( identity_id, - Some(IdentityTokenInfo::deserialize_from_bytes(&value)?), + Some(IdentityTokenInfo::deserialize_from_bytes_trusted(&value)?), )), None => Ok((identity_id, None)), _ => Err(Error::Drive(DriveError::CorruptedDriveState( diff --git a/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_info/v0/mod.rs b/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_info/v0/mod.rs index e4a5f19539f..e2ec04f322b 100644 --- a/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_info/v0/mod.rs @@ -5,7 +5,7 @@ use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; use crate::util::grove_operations::DirectQueryType; use crate::util::grove_operations::QueryTarget::QueryTargetValue; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::info::IdentityTokenInfo; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -57,7 +57,7 @@ impl Drive { drive_operations, &platform_version.drive, ) { - Ok(Some(Item(info, _))) => Ok(Some(IdentityTokenInfo::deserialize_from_bytes( + Ok(Some(Item(info, _))) => Ok(Some(IdentityTokenInfo::deserialize_from_bytes_trusted( info.as_slice(), )?)), diff --git a/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_infos/v0/mod.rs b/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_infos/v0/mod.rs index 5e1d0509407..0c7b5934e96 100644 --- a/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_infos/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/info/fetch_identity_token_infos/v0/mod.rs @@ -2,7 +2,7 @@ use crate::drive::Drive; use crate::error::drive::DriveError; use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::info::IdentityTokenInfo; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -60,7 +60,7 @@ impl Drive { match element { Some(Item(value, ..)) => Ok(( token_id, - Some(IdentityTokenInfo::deserialize_from_bytes(&value)?), + Some(IdentityTokenInfo::deserialize_from_bytes_trusted(&value)?), )), None => Ok((token_id, None)), _ => Err(Error::Drive(DriveError::CorruptedDriveState( diff --git a/packages/rs-drive/src/drive/tokens/status/fetch_token_status/v0/mod.rs b/packages/rs-drive/src/drive/tokens/status/fetch_token_status/v0/mod.rs index 3b65f7bc0dc..515ade54036 100644 --- a/packages/rs-drive/src/drive/tokens/status/fetch_token_status/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/status/fetch_token_status/v0/mod.rs @@ -5,7 +5,7 @@ use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; use crate::util::grove_operations::DirectQueryType; use crate::util::grove_operations::QueryTarget::QueryTargetValue; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::status::TokenStatus; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -54,9 +54,9 @@ impl Drive { drive_operations, &platform_version.drive, ) { - Ok(Some(Item(info, _))) => { - Ok(Some(TokenStatus::deserialize_from_bytes(info.as_slice())?)) - } + Ok(Some(Item(info, _))) => Ok(Some(TokenStatus::deserialize_from_bytes_trusted( + info.as_slice(), + )?)), Ok(None) => Ok(None), Err(Error::GroveDB(e)) if matches!(e.as_ref(), grovedb::Error::PathKeyNotFound(_)) => { diff --git a/packages/rs-drive/src/drive/tokens/status/fetch_token_statuses/v0/mod.rs b/packages/rs-drive/src/drive/tokens/status/fetch_token_statuses/v0/mod.rs index bffc5362071..5ad0d5fab76 100644 --- a/packages/rs-drive/src/drive/tokens/status/fetch_token_statuses/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/status/fetch_token_statuses/v0/mod.rs @@ -2,7 +2,7 @@ use crate::drive::Drive; use crate::error::drive::DriveError; use crate::error::Error; use crate::fees::op::LowLevelDriveOperation; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::tokens::status::TokenStatus; use dpp::version::PlatformVersion; use grovedb::Element::Item; @@ -48,9 +48,10 @@ impl Drive { )) })?; match element { - Some(Item(value, ..)) => { - Ok((token_id, Some(TokenStatus::deserialize_from_bytes(&value)?))) - } + Some(Item(value, ..)) => Ok(( + token_id, + Some(TokenStatus::deserialize_from_bytes_trusted(&value)?), + )), None => Ok((token_id, None)), _ => Err(Error::Drive(DriveError::CorruptedDriveState( "token tree for statuses should contain only items".to_string(), diff --git a/packages/rs-drive/src/drive/tokens/unfreeze/v0/mod.rs b/packages/rs-drive/src/drive/tokens/unfreeze/v0/mod.rs index f9f0339a82d..50df3b1fbfa 100644 --- a/packages/rs-drive/src/drive/tokens/unfreeze/v0/mod.rs +++ b/packages/rs-drive/src/drive/tokens/unfreeze/v0/mod.rs @@ -7,7 +7,7 @@ use crate::util::grove_operations::QueryTarget::QueryTargetValue; use dpp::block::block_info::BlockInfo; use dpp::fee::fee_result::FeeResult; use dpp::identifier::Identifier; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableTrusted, PlatformSerializable}; use dpp::tokens::info::v0::IdentityTokenInfoV0Accessors; use dpp::tokens::info::IdentityTokenInfo; use dpp::version::PlatformVersion; @@ -115,7 +115,7 @@ impl Drive { &mut drive_operations, &platform_version.drive, )? - .map(|bytes| IdentityTokenInfo::deserialize_from_bytes(&bytes)) + .map(|bytes| IdentityTokenInfo::deserialize_from_bytes_trusted(&bytes)) .transpose()? { None => { diff --git a/packages/rs-drive/src/drive/votes/fetch/fetch_contested_document_vote_poll_stored_info/v0/mod.rs b/packages/rs-drive/src/drive/votes/fetch/fetch_contested_document_vote_poll_stored_info/v0/mod.rs index 39cbe1917e6..7e4b45ac8c8 100644 --- a/packages/rs-drive/src/drive/votes/fetch/fetch_contested_document_vote_poll_stored_info/v0/mod.rs +++ b/packages/rs-drive/src/drive/votes/fetch/fetch_contested_document_vote_poll_stored_info/v0/mod.rs @@ -5,7 +5,7 @@ use crate::error::Error; use crate::util::grove_operations::DirectQueryType; use dpp::block::epoch::Epoch; use dpp::fee::fee_result::FeeResult; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::voting::vote_info_storage::contested_document_vote_poll_stored_info::ContestedDocumentVotePollStoredInfo; use grovedb::TransactionArg; use platform_version::version::PlatformVersion; @@ -53,7 +53,7 @@ impl Drive { return Ok((fee_result, None)); }; let contested_start_info_bytes = element.into_item_bytes()?; - let start_info = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes( + let start_info = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes_trusted( &contested_start_info_bytes, )?; Ok((fee_result, Some(start_info))) diff --git a/packages/rs-drive/src/drive/votes/storage_form/contested_document_resource_reference_storage_form/mod.rs b/packages/rs-drive/src/drive/votes/storage_form/contested_document_resource_reference_storage_form/mod.rs index 468c2f71126..fc59c445a9c 100644 --- a/packages/rs-drive/src/drive/votes/storage_form/contested_document_resource_reference_storage_form/mod.rs +++ b/packages/rs-drive/src/drive/votes/storage_form/contested_document_resource_reference_storage_form/mod.rs @@ -1,8 +1,8 @@ -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use grovedb::element::reference_path::ReferencePathType; /// Represents the storage form of a reference. -#[derive(Debug, Clone, PartialEq, Encode, Decode)] +#[derive(Debug, Clone, PartialEq, Encode, Decode, DecodeUntrusted)] pub struct ContestedDocumentResourceVoteReferenceStorageForm { /// The reference pub reference_path_type: ReferencePathType, diff --git a/packages/rs-drive/src/query/vote_poll_vote_state_query.rs b/packages/rs-drive/src/query/vote_poll_vote_state_query.rs index 8f224311023..3976118adf3 100644 --- a/packages/rs-drive/src/query/vote_poll_vote_state_query.rs +++ b/packages/rs-drive/src/query/vote_poll_vote_state_query.rs @@ -18,7 +18,7 @@ use dpp::block::block_info::BlockInfo; use dpp::data_contract::DataContract; use dpp::identifier::Identifier; #[cfg(feature = "server")] -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; #[cfg(feature = "server")] use dpp::voting::contender_structs::ContenderWithSerializedDocumentV0; use dpp::voting::contender_structs::{ @@ -623,7 +623,7 @@ impl ResolvedContestedDocumentVotePollDriveQuery<'_> { Element::Item(serialized_item_info, _) => { if first_key.as_slice() == RESOURCE_STORED_INFO_KEY_U8_32 { // this is the stored info, let's check to see if the vote is over - let finalized_contested_document_vote_poll_stored_info = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes(&serialized_item_info)?; + let finalized_contested_document_vote_poll_stored_info = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes_trusted(&serialized_item_info)?; if finalized_contested_document_vote_poll_stored_info .vote_poll_status() .awarded_or_locked() @@ -726,7 +726,7 @@ impl ResolvedContestedDocumentVotePollDriveQuery<'_> { Element::Item(serialized_item_info, _) => { if first_key.as_slice() == RESOURCE_STORED_INFO_KEY_U8_32 { // this is the stored info, let's check to see if the vote is over - let finalized_contested_document_vote_poll_stored_info = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes(&serialized_item_info)?; + let finalized_contested_document_vote_poll_stored_info = ContestedDocumentVotePollStoredInfo::deserialize_from_bytes_trusted(&serialized_item_info)?; if finalized_contested_document_vote_poll_stored_info .vote_poll_status() .awarded_or_locked() diff --git a/packages/rs-drive/src/query/vote_polls_by_end_date_query.rs b/packages/rs-drive/src/query/vote_polls_by_end_date_query.rs index ba138b0fac5..6508e72ba84 100644 --- a/packages/rs-drive/src/query/vote_polls_by_end_date_query.rs +++ b/packages/rs-drive/src/query/vote_polls_by_end_date_query.rs @@ -13,14 +13,14 @@ use crate::query::Query; #[cfg(feature = "server")] use crate::util::common::encode::decode_u64; use crate::util::common::encode::encode_u64; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; #[cfg(feature = "server")] use dpp::block::block_info::BlockInfo; #[cfg(feature = "server")] use dpp::fee::Credits; use dpp::prelude::{TimestampIncluded, TimestampMillis}; #[cfg(feature = "server")] -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; #[cfg(feature = "server")] use dpp::voting::vote_polls::VotePoll; #[cfg(feature = "server")] @@ -34,7 +34,7 @@ use platform_version::version::PlatformVersion; use std::collections::BTreeMap; /// Vote Poll Drive Query struct -#[derive(Debug, PartialEq, Clone, Encode, Decode)] +#[derive(Debug, PartialEq, Clone, Encode, Decode, DecodeUntrusted)] pub struct VotePollsByEndDateDriveQuery { /// What is the start time we are asking for pub start_time: Option<(TimestampMillis, TimestampIncluded)>, @@ -145,7 +145,7 @@ impl VotePollsByEndDateDriveQuery { let timestamp = decode_u64(last_path_component)?; let contested_document_resource_vote_poll_bytes = element.into_item_bytes().map_err(Error::from)?; - let vote_poll = VotePoll::deserialize_from_bytes( + let vote_poll = VotePoll::deserialize_from_bytes_trusted( &contested_document_resource_vote_poll_bytes, )?; Ok((timestamp, vote_poll)) @@ -204,7 +204,7 @@ impl VotePollsByEndDateDriveQuery { // Extract the bytes from the element let vote_poll_bytes = element.into_item_bytes().map_err(Error::from)?; // Deserialize the bytes into a VotePoll - let vote_poll = VotePoll::deserialize_from_bytes(&vote_poll_bytes)?; + let vote_poll = VotePoll::deserialize_from_bytes_trusted(&vote_poll_bytes)?; Ok(vote_poll) }) .collect::, Error>>()?; @@ -389,7 +389,7 @@ impl VotePollsByEndDateDriveQuery { let timestamp = decode_u64(last_path_component)?; let contested_document_resource_vote_poll_bytes = element.into_item_bytes().map_err(Error::from)?; - let vote_poll = VotePoll::deserialize_from_bytes( + let vote_poll = VotePoll::deserialize_from_bytes_trusted( &contested_document_resource_vote_poll_bytes, )?; Ok((timestamp, vote_poll)) diff --git a/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/mod.rs b/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/mod.rs index 6d54d4b8c33..23ccd9be7b0 100644 --- a/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/mod.rs +++ b/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/mod.rs @@ -5,6 +5,7 @@ use crate::drive::Drive; use crate::error::drive::DriveError; use crate::error::Error; use crate::verify::RootHash; +use bincode::{Decode, DecodeUntrusted, Encode}; use dpp::address_funds::PlatformAddress; use dpp::balances::credits::BlockAwareCreditOperation; use dpp::version::PlatformVersion; @@ -23,7 +24,7 @@ pub type VerifiedCompactedAddressBalanceChanges = Vec<( /// The predecessor proof independently authenticates which range, if any, /// contains the requested height. The forward proof can then be verified /// against a query derived only from that authenticated result. -#[derive(Debug, bincode::Encode, bincode::Decode)] +#[derive(Debug, Encode, Decode, DecodeUntrusted)] pub(crate) struct CompactedAddressBalanceProof { pub(crate) predecessor_proof: Vec, pub(crate) forward_proof: Vec, diff --git a/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v0/mod.rs b/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v0/mod.rs index 70d7e9fa305..ded9ecc5511 100644 --- a/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v0/mod.rs +++ b/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v0/mod.rs @@ -87,14 +87,15 @@ impl Drive { .with_limit::(); // Decode the GroveDBProof to navigate its structure - let grovedb_proof: GroveDBProof = bincode::decode_from_slice(proof, bincode_config) - .map(|(p, _)| p) - .map_err(|e| { - Error::Proof(ProofError::CorruptedProof(format!( - "cannot decode GroveDBProof: {}", - e - ))) - })?; + let grovedb_proof: GroveDBProof = + bincode::decode_from_slice_untrusted(proof, bincode_config) + .map(|(p, _)| p) + .map_err(|e| { + Error::Proof(ProofError::CorruptedProof(format!( + "cannot decode GroveDBProof: {}", + e + ))) + })?; // Navigate to the compacted address balances layer // Path: SavedBlockTransactions ('$' = 0x24) -> CompactedAddressBalances ('c' = 0x63) @@ -215,12 +216,14 @@ impl Drive { let (address_balances, consumed): ( BTreeMap, usize, - ) = bincode::decode_from_slice(&serialized_data, row_decode_config).map_err(|e| { - Error::Proof(ProofError::CorruptedProof(format!( - "cannot decode compacted address balances: {}", - e - ))) - })?; + ) = bincode::decode_from_slice_untrusted(&serialized_data, row_decode_config).map_err( + |e| { + Error::Proof(ProofError::CorruptedProof(format!( + "cannot decode compacted address balances: {}", + e + ))) + }, + )?; // Wire-safe tightening (parity with v1): honest encoders emit // rows with no trailing bytes, so rejecting them cannot break // legacy peers. diff --git a/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v1/mod.rs b/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v1/mod.rs index 07ba37b8b8f..5282613ee98 100644 --- a/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v1/mod.rs +++ b/packages/rs-drive/src/verify/address_funds/verify_compacted_address_balance_changes/v1/mod.rs @@ -81,7 +81,7 @@ impl Drive { .with_limit::(); let (proof_envelope, consumed): (CompactedAddressBalanceProof, usize) = - bincode::decode_from_slice(proof, proof_decode_config).map_err(|e| { + bincode::decode_from_slice_untrusted(proof, proof_decode_config).map_err(|e| { Error::Proof(ProofError::CorruptedProof(format!( "cannot decode compacted address balance proof: {}", e @@ -214,12 +214,14 @@ impl Drive { let (address_balances, consumed): ( BTreeMap, usize, - ) = bincode::decode_from_slice(&serialized_data, row_decode_config).map_err(|e| { - Error::Proof(ProofError::CorruptedProof(format!( - "cannot decode compacted address balances: {}", - e - ))) - })?; + ) = bincode::decode_from_slice_untrusted(&serialized_data, row_decode_config).map_err( + |e| { + Error::Proof(ProofError::CorruptedProof(format!( + "cannot decode compacted address balances: {}", + e + ))) + }, + )?; if consumed != serialized_data.len() { return Err(Error::Proof(ProofError::CorruptedProof( "compacted address balance row contains trailing bytes".to_string(), @@ -704,10 +706,10 @@ mod tests { let envelope_config = bincode::config::standard().with_big_endian(); let (before_envelope, _): (CompactedAddressBalanceProof, usize) = - bincode::decode_from_slice(&proof_before, envelope_config) + bincode::decode_from_slice_untrusted(&proof_before, envelope_config) .expect("decode earlier envelope"); let (after_envelope, _): (CompactedAddressBalanceProof, usize) = - bincode::decode_from_slice(&proof_after, envelope_config) + bincode::decode_from_slice_untrusted(&proof_after, envelope_config) .expect("decode later envelope"); let spliced = bincode::encode_to_vec( diff --git a/packages/rs-drive/src/verify/address_funds/verify_recent_address_balance_changes/v0/mod.rs b/packages/rs-drive/src/verify/address_funds/verify_recent_address_balance_changes/v0/mod.rs index 63eae115b29..2bda9434f1b 100644 --- a/packages/rs-drive/src/verify/address_funds/verify_recent_address_balance_changes/v0/mod.rs +++ b/packages/rs-drive/src/verify/address_funds/verify_recent_address_balance_changes/v0/mod.rs @@ -33,7 +33,7 @@ fn decode_address_balance_row( .with_big_endian() .with_limit::(); let (address_balances, consumed): (BTreeMap, usize) = - bincode::decode_from_slice(serialized_data, config).map_err(|e| { + bincode::decode_from_slice_untrusted(serialized_data, config).map_err(|e| { Error::Proof(ProofError::CorruptedProof(format!( "cannot decode address balances: {}", e diff --git a/packages/rs-drive/src/verify/bounded_decode.rs b/packages/rs-drive/src/verify/bounded_decode.rs index c886bd0ab7b..7b324a89904 100644 --- a/packages/rs-drive/src/verify/bounded_decode.rs +++ b/packages/rs-drive/src/verify/bounded_decode.rs @@ -38,7 +38,7 @@ pub(super) fn decode_proof_data_contract( let config = bincode::config::standard() .with_big_endian() .with_limit::(); - let (serialized_format, consumed) = bincode::borrow_decode_from_slice::< + let (serialized_format, consumed) = bincode::borrow_decode_from_slice_untrusted::< DataContractInSerializationFormat, _, >(serialized_contract, config) @@ -78,8 +78,8 @@ pub(super) fn decode_vote_reference( let config = bincode::config::standard() .with_big_endian() .with_limit::(); - let (reference, consumed) = - bincode::decode_from_slice(serialized_reference, config).map_err(|e| { + let (reference, consumed) = bincode::decode_from_slice_untrusted(serialized_reference, config) + .map_err(|e| { Error::Drive(DriveError::CorruptedSerialization(format!( "serialized vote reference is invalid: {e}" ))) diff --git a/packages/rs-drive/src/verify/contract/verify_contract_return_serialization/v0/mod.rs b/packages/rs-drive/src/verify/contract/verify_contract_return_serialization/v0/mod.rs index b93d3f4ece8..ebbf83af0d7 100644 --- a/packages/rs-drive/src/verify/contract/verify_contract_return_serialization/v0/mod.rs +++ b/packages/rs-drive/src/verify/contract/verify_contract_return_serialization/v0/mod.rs @@ -160,7 +160,7 @@ mod tests { use crate::util::test_helpers::setup::setup_drive_with_initial_state_structure; use dpp::block::block_info::BlockInfo; use dpp::data_contract::accessors::v0::DataContractV0Getters; - use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dpp::tests::fixtures::get_dpns_data_contract_fixture; use dpp::version::PlatformVersion; @@ -204,7 +204,7 @@ mod tests { assert_eq!(verified_contract.version(), contract.version()); // Verify the serialized bytes can be deserialized back to the same contract - let deserialized = dpp::prelude::DataContract::versioned_deserialize( + let deserialized = dpp::prelude::DataContract::versioned_deserialize_untrusted( &serialized_bytes, false, platform_version, diff --git a/packages/rs-drive/src/verify/group/verify_active_action_infos/v0/mod.rs b/packages/rs-drive/src/verify/group/verify_active_action_infos/v0/mod.rs index 60363291863..f3de4798a07 100644 --- a/packages/rs-drive/src/verify/group/verify_active_action_infos/v0/mod.rs +++ b/packages/rs-drive/src/verify/group/verify_active_action_infos/v0/mod.rs @@ -11,7 +11,7 @@ use dpp::group::group_action::GroupAction; use dpp::group::group_action_status::GroupActionStatus; use dpp::identifier::Identifier; use dpp::prelude::StartAtIncluded; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -55,10 +55,11 @@ impl Drive { match element { Some(Item(value, ..)) => { - let active_action = match GroupAction::deserialize_from_bytes(&value) { - Ok(active_action) => active_action, - Err(e) => return Some(Err(e.into())), - }; + let active_action = + match GroupAction::deserialize_from_bytes_untrusted(&value) { + Ok(active_action) => active_action, + Err(e) => return Some(Err(e.into())), + }; Some(Ok((action_id, active_action))) } None => None, diff --git a/packages/rs-drive/src/verify/group/verify_group_info/v0/mod.rs b/packages/rs-drive/src/verify/group/verify_group_info/v0/mod.rs index 8763a910119..21bd85d4d9a 100644 --- a/packages/rs-drive/src/verify/group/verify_group_info/v0/mod.rs +++ b/packages/rs-drive/src/verify/group/verify_group_info/v0/mod.rs @@ -8,7 +8,7 @@ use crate::verify::RootHash; use dpp::data_contract::group::Group; use dpp::data_contract::GroupContractPosition; use dpp::identifier::Identifier; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -49,7 +49,7 @@ impl Drive { let group = element .map(|element| element.into_item_bytes().map_err(Error::from)) .transpose()? - .map(|bytes| Group::deserialize_from_bytes(&bytes)) + .map(|bytes| Group::deserialize_from_bytes_untrusted(&bytes)) .transpose()?; Ok((root_hash, group)) diff --git a/packages/rs-drive/src/verify/group/verify_group_infos_in_contract/v0/mod.rs b/packages/rs-drive/src/verify/group/verify_group_infos_in_contract/v0/mod.rs index 77f59f2c6e8..af57b594e8a 100644 --- a/packages/rs-drive/src/verify/group/verify_group_infos_in_contract/v0/mod.rs +++ b/packages/rs-drive/src/verify/group/verify_group_infos_in_contract/v0/mod.rs @@ -10,7 +10,7 @@ use dpp::data_contract::group::Group; use dpp::data_contract::GroupContractPosition; use dpp::identifier::Identifier; use dpp::prelude::StartAtIncluded; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -58,7 +58,7 @@ impl Drive { GroupContractPosition::from_be_bytes(key_bytes); match element { Some(Item(value, ..)) => { - let group = match Group::deserialize_from_bytes(&value) { + let group = match Group::deserialize_from_bytes_untrusted(&value) { Ok(group) => group, Err(e) => return Some(Err(e.into())), }; diff --git a/packages/rs-drive/src/verify/identity/verify_full_identity_by_identity_id/v0/mod.rs b/packages/rs-drive/src/verify/identity/verify_full_identity_by_identity_id/v0/mod.rs index c995a902b46..5bc0603007e 100644 --- a/packages/rs-drive/src/verify/identity/verify_full_identity_by_identity_id/v0/mod.rs +++ b/packages/rs-drive/src/verify/identity/verify_full_identity_by_identity_id/v0/mod.rs @@ -12,7 +12,7 @@ use dpp::identifier::Identifier; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{IdentityPublicKey, IdentityV0, KeyID}; pub use dpp::prelude::{Identity, Revision}; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::version::PlatformVersion; use grovedb::GroveDb; use std::collections::BTreeMap; @@ -104,7 +104,7 @@ impl Drive { } else if path == identity_keys_path { if let Some(element) = maybe_element { let item_bytes = element.into_item_bytes().map_err(Error::from)?; - let key = IdentityPublicKey::deserialize_from_bytes(&item_bytes)?; + let key = IdentityPublicKey::deserialize_from_bytes_untrusted(&item_bytes)?; keys.insert(key.id(), key); } else { return Err(Error::Proof(ProofError::CorruptedProof( diff --git a/packages/rs-drive/src/verify/identity/verify_identities_contract_keys/v0/mod.rs b/packages/rs-drive/src/verify/identity/verify_identities_contract_keys/v0/mod.rs index 2ea58065062..8d858dc2e68 100644 --- a/packages/rs-drive/src/verify/identity/verify_identities_contract_keys/v0/mod.rs +++ b/packages/rs-drive/src/verify/identity/verify_identities_contract_keys/v0/mod.rs @@ -8,7 +8,7 @@ use dpp::identity::{IdentityPublicKey, Purpose}; use crate::error::drive::DriveError; use dpp::identity::identities_contract_keys::IdentitiesContractKeys; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::version::PlatformVersion; use grovedb::GroveDb; use std::collections::BTreeMap; @@ -111,7 +111,7 @@ impl Drive { .transpose()?; let maybe_identity_public_key = maybe_item_bytes - .map(IdentityPublicKey::deserialize_from_bytes) + .map(IdentityPublicKey::deserialize_from_bytes_untrusted) .transpose()?; entry.insert(purpose, maybe_identity_public_key); diff --git a/packages/rs-drive/src/verify/identity/verify_identity_keys_by_identity_id/v0/mod.rs b/packages/rs-drive/src/verify/identity/verify_identity_keys_by_identity_id/v0/mod.rs index eced1a499ef..7d6ab2c9ab1 100644 --- a/packages/rs-drive/src/verify/identity/verify_identity_keys_by_identity_id/v0/mod.rs +++ b/packages/rs-drive/src/verify/identity/verify_identity_keys_by_identity_id/v0/mod.rs @@ -12,7 +12,7 @@ use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV use dpp::identity::{IdentityPublicKey, KeyID, PartialIdentity}; use dpp::prelude::Revision; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::version::PlatformVersion; use grovedb::{GroveDb, PathQuery}; use std::collections::BTreeMap; @@ -83,7 +83,7 @@ impl Drive { if path == identity_keys_path { if let Some(element) = maybe_element { let item_bytes = element.into_item_bytes().map_err(Error::from)?; - let key = IdentityPublicKey::deserialize_from_bytes(&item_bytes)?; + let key = IdentityPublicKey::deserialize_from_bytes_untrusted(&item_bytes)?; loaded_public_keys.insert(key.id(), key); } else { return Err(Error::Proof(ProofError::CorruptedProof( diff --git a/packages/rs-drive/src/verify/state_transition/verify_state_transition_was_executed_with_proof/v0/mod.rs b/packages/rs-drive/src/verify/state_transition/verify_state_transition_was_executed_with_proof/v0/mod.rs index d11e6cdc939..47a467910e8 100644 --- a/packages/rs-drive/src/verify/state_transition/verify_state_transition_was_executed_with_proof/v0/mod.rs +++ b/packages/rs-drive/src/verify/state_transition/verify_state_transition_was_executed_with_proof/v0/mod.rs @@ -1693,7 +1693,7 @@ impl Drive { use dpp::asset_lock::reduced_asset_lock_value::AssetLockValue; use dpp::asset_lock::StoredAssetLockInfo; use dpp::identity::state_transition::AssetLockProved; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::proof_result::StateTransitionProofResult::{ VerifiedAssetLockConsumed, VerifiedAssetLockConsumedWithAddressInfos, }; @@ -1805,7 +1805,7 @@ impl Drive { StoredAssetLockInfo::FullyConsumed } else { StoredAssetLockInfo::PartiallyConsumed( - AssetLockValue::deserialize_from_bytes(&bytes)?, + AssetLockValue::deserialize_from_bytes_untrusted(&bytes)?, ) } } @@ -1849,7 +1849,9 @@ impl Drive { StoredAssetLockInfo::FullyConsumed } else { StoredAssetLockInfo::PartiallyConsumed( - AssetLockValue::deserialize_from_bytes(&bytes)?, + AssetLockValue::deserialize_from_bytes_untrusted( + &bytes, + )?, ) } } @@ -1884,7 +1886,7 @@ impl Drive { use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{IdentityPublicKey, IdentityV0, KeyID}; use dpp::prelude::Revision; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::identity_create_from_shielded_pool_transition::accessors::IdentityCreateFromShieldedPoolTransitionAccessorsV0; use dpp::state_transition::identity_create_from_shielded_pool_transition::derive_identity_id_from_actions; use dpp::state_transition::proof_result::StateTransitionProofResult::VerifiedIdentityWithShieldedNullifiers; @@ -2005,7 +2007,8 @@ impl Drive { )) })?; let item_bytes = element.into_item_bytes().map_err(Error::from)?; - let public_key = IdentityPublicKey::deserialize_from_bytes(&item_bytes)?; + let public_key = + IdentityPublicKey::deserialize_from_bytes_untrusted(&item_bytes)?; keys.insert(public_key.id(), public_key); } else { return Err(Error::Proof(ProofError::TooManyElements( @@ -2088,7 +2091,7 @@ impl Drive { use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; use dpp::identity::{IdentityPublicKey, IdentityV0, KeyID}; use dpp::prelude::Revision; - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::identity_top_up_from_shielded_pool_transition::accessors::IdentityTopUpFromShieldedPoolTransitionAccessorsV0; use dpp::state_transition::proof_result::StateTransitionProofResult::VerifiedIdentityWithShieldedNullifiers; use std::collections::{BTreeMap, BTreeSet}; @@ -2199,7 +2202,8 @@ impl Drive { )) })?; let item_bytes = element.into_item_bytes().map_err(Error::from)?; - let public_key = IdentityPublicKey::deserialize_from_bytes(&item_bytes)?; + let public_key = + IdentityPublicKey::deserialize_from_bytes_untrusted(&item_bytes)?; keys.insert(public_key.id(), public_key); } else { return Err(Error::Proof(ProofError::TooManyElements( diff --git a/packages/rs-drive/src/verify/system/verify_finalized_epoch_infos/v0/mod.rs b/packages/rs-drive/src/verify/system/verify_finalized_epoch_infos/v0/mod.rs index 631141cec6c..29b5ae7cf6a 100644 --- a/packages/rs-drive/src/verify/system/verify_finalized_epoch_infos/v0/mod.rs +++ b/packages/rs-drive/src/verify/system/verify_finalized_epoch_infos/v0/mod.rs @@ -7,7 +7,7 @@ use crate::error::Error; use crate::verify::RootHash; use dpp::block::epoch::{EpochIndex, EPOCH_KEY_OFFSET}; use dpp::block::finalized_epoch_info::FinalizedEpochInfo; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use grovedb::{Element, GroveDb}; use platform_version::version::PlatformVersion; use std::collections::BTreeMap; @@ -120,7 +120,7 @@ impl Drive { }; // Deserialize the FinalizedEpochInfo - match FinalizedEpochInfo::deserialize_from_bytes(item_bytes) { + match FinalizedEpochInfo::deserialize_from_bytes_untrusted(item_bytes) { Ok(epoch_info) => Some(Ok((epoch_index, epoch_info))), Err(e) => Some(Err(e.into())), } diff --git a/packages/rs-drive/src/verify/tokens/verify_token_contract_info/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_contract_info/v0/mod.rs index f7bd406952d..5370667986e 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_contract_info/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_contract_info/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::contract_info::TokenContractInfo; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -37,7 +37,7 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( root_hash, - Some(TokenContractInfo::deserialize_from_bytes(&value)?), + Some(TokenContractInfo::deserialize_from_bytes_untrusted(&value)?), )), None => Ok((root_hash, None)), _ => Err(Error::Proof(ProofError::IncorrectValueSize( diff --git a/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_price/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_price/v0/mod.rs index 77edad2a32e..f37b8bb869d 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_price/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_price/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -37,7 +37,9 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( root_hash, - Some(TokenPricingSchedule::deserialize_from_bytes(&value)?), + Some(TokenPricingSchedule::deserialize_from_bytes_untrusted( + &value, + )?), )), None => Ok((root_hash, None)), _ => Err(Error::Proof(ProofError::IncorrectValueSize( diff --git a/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_prices/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_prices/v0/mod.rs index ba9d5a08c87..101a5ad329c 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_prices/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_direct_selling_prices/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::token_pricing_schedule::TokenPricingSchedule; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -45,7 +45,9 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( token_id.into(), - Some(TokenPricingSchedule::deserialize_from_bytes(&value)?), + Some(TokenPricingSchedule::deserialize_from_bytes_untrusted( + &value, + )?), )), None => Ok((token_id.into(), None)), _ => Err(Error::Proof(ProofError::IncorrectValueSize( diff --git a/packages/rs-drive/src/verify/tokens/verify_token_info_for_identity_id/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_info_for_identity_id/v0/mod.rs index 6802b7e4421..5b4a843bd16 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_info_for_identity_id/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_info_for_identity_id/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::info::IdentityTokenInfo; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -38,7 +38,7 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( root_hash, - Some(IdentityTokenInfo::deserialize_from_bytes(&value)?), + Some(IdentityTokenInfo::deserialize_from_bytes_untrusted(&value)?), )), None => Ok((root_hash, None)), _ => Err(Error::Proof(ProofError::IncorrectValueSize( diff --git a/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_id/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_id/v0/mod.rs index 978d6d76a67..2effe552193 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_id/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_id/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::info::IdentityTokenInfo; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -54,7 +54,7 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( token_id.into(), - Some(IdentityTokenInfo::deserialize_from_bytes(&value)?), + Some(IdentityTokenInfo::deserialize_from_bytes_untrusted(&value)?), )), None => Ok((token_id.into(), None)), _ => Err(Error::Proof(ProofError::IncorrectProof( diff --git a/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_ids/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_ids/v0/mod.rs index 46c11529755..faa98421bea 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_ids/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_infos_for_identity_ids/v0/mod.rs @@ -5,7 +5,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::info::IdentityTokenInfo; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -48,7 +48,8 @@ impl Drive { None => Ok((key.into(), None)), Some(element) => { let info_bytes = element.as_item_bytes().map_err(Error::from)?; - let info = IdentityTokenInfo::deserialize_from_bytes(info_bytes)?; + let info = + IdentityTokenInfo::deserialize_from_bytes_untrusted(info_bytes)?; Ok((key.into(), Some(info))) } } diff --git a/packages/rs-drive/src/verify/tokens/verify_token_status/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_status/v0/mod.rs index 60aedb908fc..acc1cfcea1c 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_status/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_status/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::status::TokenStatus; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -37,7 +37,7 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( root_hash, - Some(TokenStatus::deserialize_from_bytes(&value)?), + Some(TokenStatus::deserialize_from_bytes_untrusted(&value)?), )), None => Ok((root_hash, None)), _ => Err(Error::Proof(ProofError::IncorrectValueSize( diff --git a/packages/rs-drive/src/verify/tokens/verify_token_statuses/v0/mod.rs b/packages/rs-drive/src/verify/tokens/verify_token_statuses/v0/mod.rs index b40cc535cd5..a2dfd02c45e 100644 --- a/packages/rs-drive/src/verify/tokens/verify_token_statuses/v0/mod.rs +++ b/packages/rs-drive/src/verify/tokens/verify_token_statuses/v0/mod.rs @@ -6,7 +6,7 @@ use crate::error::Error; use crate::verify::RootHash; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::tokens::status::TokenStatus; use grovedb::GroveDb; use platform_version::version::PlatformVersion; @@ -45,7 +45,7 @@ impl Drive { match proved_key_value.2 { Some(Item(value, ..)) => Ok(( token_id.into(), - Some(TokenStatus::deserialize_from_bytes(&value)?), + Some(TokenStatus::deserialize_from_bytes_untrusted(&value)?), )), None => Ok((token_id.into(), None)), _ => Err(Error::Proof(ProofError::IncorrectValueSize( diff --git a/packages/rs-drive/src/verify/voting/verify_vote_poll_vote_state_proof/v0/mod.rs b/packages/rs-drive/src/verify/voting/verify_vote_poll_vote_state_proof/v0/mod.rs index 3637ec314c0..7202a3dc16b 100644 --- a/packages/rs-drive/src/verify/voting/verify_vote_poll_vote_state_proof/v0/mod.rs +++ b/packages/rs-drive/src/verify/voting/verify_vote_poll_vote_state_proof/v0/mod.rs @@ -1,6 +1,6 @@ use crate::verify::RootHash; use dpp::identifier::Identifier; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use grovedb::{Element, GroveDb}; use crate::error::Error; @@ -138,7 +138,7 @@ impl ResolvedContestedDocumentVotePollDriveQuery<'_> { if first_key.as_slice() == RESOURCE_STORED_INFO_KEY_U8_32 { // this is the stored info, let's check to see if the vote is over let finalized_contested_document_vote_poll_stored_info = - ContestedDocumentVotePollStoredInfo::deserialize_from_bytes( + ContestedDocumentVotePollStoredInfo::deserialize_from_bytes_untrusted( &serialized_item_info, )?; if finalized_contested_document_vote_poll_stored_info @@ -249,7 +249,7 @@ impl ResolvedContestedDocumentVotePollDriveQuery<'_> { if first_key.as_slice() == RESOURCE_STORED_INFO_KEY_U8_32 { // this is the stored info, let's check to see if the vote is over let finalized_contested_document_vote_poll_stored_info = - ContestedDocumentVotePollStoredInfo::deserialize_from_bytes( + ContestedDocumentVotePollStoredInfo::deserialize_from_bytes_untrusted( &serialized_item_info, )?; if finalized_contested_document_vote_poll_stored_info diff --git a/packages/rs-drive/src/verify/voting/verify_vote_polls_end_date_query/v0/mod.rs b/packages/rs-drive/src/verify/voting/verify_vote_polls_end_date_query/v0/mod.rs index 8dc3938a010..8fe293d5c14 100644 --- a/packages/rs-drive/src/verify/voting/verify_vote_polls_end_date_query/v0/mod.rs +++ b/packages/rs-drive/src/verify/voting/verify_vote_polls_end_date_query/v0/mod.rs @@ -1,6 +1,6 @@ use crate::verify::RootHash; use dpp::prelude::TimestampMillis; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use grovedb::GroveDb; use std::collections::BTreeMap; @@ -65,7 +65,7 @@ impl VotePollsByEndDateDriveQuery { }; let timestamp = decode_u64(last_path_component)?; let vote_poll_bytes = element.into_item_bytes().map_err(Error::from)?; - let vote_poll = VotePoll::deserialize_from_bytes(&vote_poll_bytes)?; + let vote_poll = VotePoll::deserialize_from_bytes_untrusted(&vote_poll_bytes)?; Ok((timestamp, vote_poll)) }) .collect::, Error>>()? diff --git a/packages/rs-platform-serialization-derive/src/deserialize_enum.rs b/packages/rs-platform-serialization-derive/src/deserialize_enum.rs index 28fa18dcd29..25829d37753 100644 --- a/packages/rs-platform-serialization-derive/src/deserialize_enum.rs +++ b/packages/rs-platform-serialization-derive/src/deserialize_enum.rs @@ -1,4 +1,4 @@ -use crate::VersionAttributes; +use crate::{DecodeTrust, TrustNames, VersionAttributes}; use proc_macro::TokenStream; use proc_macro2::Ident; use quote::{format_ident, quote}; @@ -14,7 +14,7 @@ pub(super) fn derive_platform_deserialize_enum( ) -> TokenStream { let VersionAttributes { passthrough, - unversioned, + trust, platform_version_path, platform_serialize_limit, untagged, @@ -22,6 +22,17 @@ pub(super) fn derive_platform_deserialize_enum( .. } = version_attributes; + let TrustNames { + decode_from_slice, + deserializable, + deserialize, + deserialize_no_limit, + from_versioned_structure, + versioned_deserialize, + limit_from_versioned_structure, + versioned_limit_deserialize, + } = trust.names(); + let generics = &input.generics; let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); @@ -29,24 +40,16 @@ pub(super) fn derive_platform_deserialize_enum( #crate_name::#error_type::PlatformDeserializationError(format!("unable to deserialize {} : {}", stringify!(#name), e)) })}; - // if we have passthrough or untagged we can't decode directly - let bincode_decode_body = if !passthrough && !untagged { - if unversioned { - let bincode_decode_body: proc_macro2::TokenStream = - crate::derive_bincode::derive_decode_inner(token_stream_input.clone()) - .unwrap_or_else(|e| e.into_token_stream()) - .into(); - quote! { - #bincode_decode_body - } - } else { - let bincode_decode_body: proc_macro2::TokenStream = - crate::derive_bincode::derive_decode_inner(token_stream_input.clone()) - .unwrap_or_else(|e| e.into_token_stream()) - .into(); - quote! { - #bincode_decode_body - } + // if we have passthrough or untagged we can't decode directly. Only the + // trusted derive emits the ordinary `PlatformVersionedDecode` body, so a + // type deriving both trust levels gets it exactly once. + let bincode_decode_body = if !passthrough && !untagged && trust == DecodeTrust::Trusted { + let bincode_decode_body: proc_macro2::TokenStream = + crate::derive_bincode::derive_decode_inner(token_stream_input.clone()) + .unwrap_or_else(|e| e.into_token_stream()) + .into(); + quote! { + #bincode_decode_body } } else { quote! {} @@ -112,7 +115,7 @@ pub(super) fn derive_platform_deserialize_enum( quote! { #index => { let config = bincode::config::standard().with_big_endian().with_no_limit(); - let deserialized : #versioned_variant_name = bincode::decode_from_slice(&data, config)#map_err?; + let deserialized : #versioned_variant_name = #decode_from_slice(&data, config)#map_err?; deserialized.into() }, } @@ -129,8 +132,8 @@ pub(super) fn derive_platform_deserialize_enum( }; let without_limit = quote! { - impl #impl_generics #crate_name::serialization::PlatformDeserializableFromVersionedStructure for #name #ty_generics #where_clause { - fn versioned_deserialize( + impl #impl_generics #crate_name::serialization::#from_versioned_structure for #name #ty_generics #where_clause { + fn #versioned_deserialize( data: &[u8], platform_version: &platform_version::version::PlatformVersion, ) -> Result @@ -156,7 +159,7 @@ pub(super) fn derive_platform_deserialize_enum( quote! { #index => { let config = bincode::config::standard().with_big_endian().with_big_endian().with_limit::<{ #limit }>(); - let deserialized : #versioned_variant_name = bincode::decode_from_slice(&data, config)#map_err?; + let deserialized : #versioned_variant_name = #decode_from_slice(&data, config)#map_err?; deserialized.into() }, } @@ -173,8 +176,8 @@ pub(super) fn derive_platform_deserialize_enum( }; quote! { - impl #impl_generics #crate_name::serialization::PlatformLimitDeserializableFromVersionedStructure for #name #ty_generics #where_clause { - fn versioned_limit_deserialize( + impl #impl_generics #crate_name::serialization::#limit_from_versioned_structure for #name #ty_generics #where_clause { + fn #versioned_limit_deserialize( data: &[u8], platform_version: &platform_version::version::PlatformVersion, ) -> Result @@ -213,45 +216,45 @@ pub(super) fn derive_platform_deserialize_enum( }) }; quote! { - impl #impl_generics #crate_name::serialization::PlatformDeserializable for #name #ty_generics #where_clause { - fn deserialize_from_bytes( + impl #impl_generics #crate_name::serialization::#deserializable for #name #ty_generics #where_clause { + fn #deserialize( data: &[u8] ) -> Result where Self: Sized { let config = bincode::config::standard().with_big_endian().with_limit::<{ #limit }>(); - bincode::decode_from_slice(&data, config).map(|(a,_)| a)#limit_map_err + #decode_from_slice(&data, config).map(|(a,_)| a)#limit_map_err } - fn deserialize_from_bytes_no_limit( + fn #deserialize_no_limit( data: &[u8] ) -> Result where Self: Sized { let config = bincode::config::standard().with_big_endian().with_no_limit(); - bincode::decode_from_slice(&data, config).map(|(a,_)| a)#map_err + #decode_from_slice(&data, config).map(|(a,_)| a)#map_err } } } } else { quote! { - impl #impl_generics #crate_name::serialization::PlatformDeserializable for #name #ty_generics #where_clause { - fn deserialize_from_bytes( + impl #impl_generics #crate_name::serialization::#deserializable for #name #ty_generics #where_clause { + fn #deserialize( data: &[u8] ) -> Result where Self: Sized { let config = bincode::config::standard().with_big_endian().with_no_limit(); - bincode::decode_from_slice(&data, config).map(|(a,_)| a)#map_err + #decode_from_slice(&data, config).map(|(a,_)| a)#map_err } - fn deserialize_from_bytes_no_limit( + fn #deserialize_no_limit( data: &[u8] ) -> Result where Self: Sized { let config = bincode::config::standard().with_big_endian().with_no_limit(); - bincode::decode_from_slice(&data, config).map(|(a,_)| a)#map_err + #decode_from_slice(&data, config).map(|(a,_)| a)#map_err } } } diff --git a/packages/rs-platform-serialization-derive/src/deserialize_struct.rs b/packages/rs-platform-serialization-derive/src/deserialize_struct.rs index bfac190dbe5..9a53965cbcc 100644 --- a/packages/rs-platform-serialization-derive/src/deserialize_struct.rs +++ b/packages/rs-platform-serialization-derive/src/deserialize_struct.rs @@ -1,4 +1,4 @@ -use crate::VersionAttributes; +use crate::{DecodeTrust, TrustNames, VersionAttributes}; use proc_macro::TokenStream; use proc_macro2::Ident; use quote::quote; @@ -15,11 +15,30 @@ pub(super) fn derive_platform_deserialize_struct( let VersionAttributes { crate_name, unversioned, + trust, platform_serialize_limit, platform_serialize_into, .. } = version_attributes; + let TrustNames { + decode_from_slice, + deserializable, + deserialize, + deserialize_no_limit, + from_versioned_structure, + versioned_deserialize, + limit_from_versioned_structure, + versioned_limit_deserialize, + } = trust.names(); + + if !unversioned && trust == DecodeTrust::Untrusted { + panic!( + "PlatformDeserializeUntrusted needs `platform_serialize(unversioned)`: a versioned \ + structure decodes through PlatformVersionedDecode, which has no untrusted form" + ); + } + // Extract the generics. let generics = &input.generics; let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); @@ -54,7 +73,7 @@ pub(super) fn derive_platform_deserialize_struct( let deserialize_into = match platform_serialize_into { Some(inner) => quote! { #config - let inner: #inner = bincode::decode_from_slice(bytes, config).map(|(a, _)| a)?; + let inner: #inner = #decode_from_slice(bytes, config).map(|(a, _)| a)?; Ok(inner.into()) }, None => { @@ -66,7 +85,7 @@ pub(super) fn derive_platform_deserialize_struct( } else { quote! { #config - bincode::decode_from_slice(bytes, config).map(|(a,_)| a) + #decode_from_slice(bytes, config).map(|(a,_)| a) #limit_err } } @@ -75,24 +94,25 @@ pub(super) fn derive_platform_deserialize_struct( // if we have passthrough or untagged we can't decode directly - let bincode_decode_body: proc_macro2::TokenStream = + // Only the trusted derive emits the ordinary `PlatformVersionedDecode` body, + // so a type deriving both trust levels gets it exactly once. + let bincode_decode_body: proc_macro2::TokenStream = if trust == DecodeTrust::Trusted { crate::derive_bincode::derive_decode_inner(token_stream_input.clone()) .unwrap_or_else(|e| e.into_token_stream()) - .into(); - - // let bincode_decode_body = quote! { - // #bincode_decode_body - // }; + .into() + } else { + quote! {} + }; let expanded = if unversioned { quote! { - impl #impl_generics #crate_name::serialization::PlatformDeserializable for #name #ty_generics #where_clause + impl #impl_generics #crate_name::serialization::#deserializable for #name #ty_generics #where_clause { - fn deserialize_from_bytes(bytes: &[u8]) -> Result { + fn #deserialize(bytes: &[u8]) -> Result { #deserialize_into } - fn deserialize_from_bytes_no_limit(bytes: &[u8]) -> Result { + fn #deserialize_no_limit(bytes: &[u8]) -> Result { #deserialize_into } } @@ -101,16 +121,16 @@ pub(super) fn derive_platform_deserialize_struct( } } else { quote! { - impl #impl_generics #crate_name::serialization::PlatformDeserializableFromVersionedStructure for #name #ty_generics #where_clause + impl #impl_generics #crate_name::serialization::#from_versioned_structure for #name #ty_generics #where_clause { - fn versioned_deserialize(bytes: &[u8], platform_version: &#crate_name::version::PlatformVersion) -> Result { + fn #versioned_deserialize(bytes: &[u8], platform_version: &#crate_name::version::PlatformVersion) -> Result { #deserialize_into } } - impl #impl_generics #crate_name::serialization::PlatformLimitDeserializableFromVersionedStructure for #name #ty_generics #where_clause + impl #impl_generics #crate_name::serialization::#limit_from_versioned_structure for #name #ty_generics #where_clause { - fn versioned_limit_deserialize(bytes: &[u8], platform_version: &#crate_name::version::PlatformVersion) -> Result { + fn #versioned_limit_deserialize(bytes: &[u8], platform_version: &#crate_name::version::PlatformVersion) -> Result { #deserialize_into } } diff --git a/packages/rs-platform-serialization-derive/src/lib.rs b/packages/rs-platform-serialization-derive/src/lib.rs index 601d891abb5..cd746053f0c 100644 --- a/packages/rs-platform-serialization-derive/src/lib.rs +++ b/packages/rs-platform-serialization-derive/src/lib.rs @@ -15,7 +15,7 @@ use crate::serialize_enum::derive_platform_serialize_enum; use crate::serialize_struct::derive_platform_serialize_struct; use proc_macro::TokenStream; use proc_macro2::{Ident, Span}; -use quote::quote; +use quote::{format_ident, quote}; use syn::{parse_macro_input, Data, DeriveInput, Expr, Lit, LitInt, LitStr, Meta, Path}; struct VersionAttributes { @@ -24,6 +24,7 @@ struct VersionAttributes { platform_serialize_limit: Option, untagged: bool, unversioned: bool, + trust: DecodeTrust, platform_serialize_into: Option, platform_version_path: Option, #[allow(dead_code)] // TODO this is never read @@ -32,6 +33,60 @@ struct VersionAttributes { force_prepend_version: bool, } +/// Which bincode decoder a derived deserialization runs. +#[derive(Clone, Copy, PartialEq, Eq)] +enum DecodeTrust { + /// Bytes this node wrote itself: Drive state read back from GroveDB, + /// wallet storage, locally generated fixtures. Ordinary decoding, which + /// reserves each collection from its length prefix. + Trusted, + /// Bytes from a peer, a client, a proof or a host caller. Untrusted + /// decoding, which reserves nothing from a length prefix before the + /// elements it announces have actually been read. + Untrusted, +} + +/// The trait and method names one trust level derives. +struct TrustNames { + decode_from_slice: proc_macro2::TokenStream, + deserializable: Ident, + deserialize: Ident, + deserialize_no_limit: Ident, + from_versioned_structure: Ident, + versioned_deserialize: Ident, + limit_from_versioned_structure: Ident, + versioned_limit_deserialize: Ident, +} + +impl DecodeTrust { + fn names(self) -> TrustNames { + let (trait_suffix, fn_suffix, decode_from_slice) = match self { + DecodeTrust::Trusted => ("Trusted", "trusted", quote! { bincode::decode_from_slice }), + DecodeTrust::Untrusted => ( + "Untrusted", + "untrusted", + quote! { bincode::decode_from_slice_untrusted }, + ), + }; + TrustNames { + decode_from_slice, + deserializable: format_ident!("PlatformDeserializable{}", trait_suffix), + deserialize: format_ident!("deserialize_from_bytes_{}", fn_suffix), + deserialize_no_limit: format_ident!("deserialize_from_bytes_{}_no_limit", fn_suffix), + from_versioned_structure: format_ident!( + "PlatformDeserializableFromVersionedStructure{}", + trait_suffix + ), + versioned_deserialize: format_ident!("versioned_deserialize_{}", fn_suffix), + limit_from_versioned_structure: format_ident!( + "PlatformLimitDeserializableFromVersionedStructure{}", + trait_suffix + ), + versioned_limit_deserialize: format_ident!("versioned_limit_deserialize_{}", fn_suffix), + } + } +} + impl VersionAttributes { fn check_for_enum(&self) { if self.platform_serialize_into.is_some() { @@ -184,6 +239,7 @@ pub fn derive_platform_serialize(input: TokenStream) -> TokenStream { platform_serialize_limit, untagged, unversioned, + trust: DecodeTrust::Trusted, platform_serialize_into, platform_version_path, allow_prepend_version, @@ -219,11 +275,44 @@ pub fn derive_platform_serialize(input: TokenStream) -> TokenStream { } } +/// Derive Platform deserialization for bytes this node wrote itself. +/// +/// Implements `PlatformDeserializableTrusted` (`deserialize_from_bytes_trusted`) +/// and, for versioned structures, the `...FromVersionedStructureTrusted` twins, +/// all running bincode's ordinary decoder, which reserves each collection from +/// its length prefix. Use the trusted entry points for Drive state read back +/// from GroveDB, wallet storage and locally generated fixtures; never for bytes +/// that arrived from a peer, a client, a proof or a host caller, which go +/// through [`PlatformDeserializeUntrusted`]. A type can derive both. +/// +/// This derive also emits the type's `PlatformVersionedDecode` implementation, +/// which the versioned (non-`unversioned`) structures and the SDK mocks rely on. +#[proc_macro_derive( + PlatformDeserializeTrusted, + attributes(platform_error_type, platform_serialize) +)] +pub fn derive_platform_deserialize_trusted(input: TokenStream) -> TokenStream { + derive_platform_deserialize(input, DecodeTrust::Trusted) +} + +/// Derive Platform deserialization for bytes from outside this node. +/// +/// Implements `PlatformDeserializableUntrusted` (`deserialize_from_bytes_untrusted`) +/// running bincode's untrusted decoder, so a short input whose length prefix +/// claims a huge collection fails before anything is reserved for it. The type +/// and every field need `DecodeUntrusted`. Existing configured budgets and +/// domain validation still apply; untrusted decoding adds no universal budget. +/// Versioned structures have no untrusted form: `PlatformVersionedDecode` is an +/// ordinary decoder, so this derive requires `platform_serialize(unversioned)`. #[proc_macro_derive( - PlatformDeserialize, + PlatformDeserializeUntrusted, attributes(platform_error_type, platform_serialize) )] -pub fn derive_platform_deserialize(input: TokenStream) -> TokenStream { +pub fn derive_platform_deserialize_untrusted(input: TokenStream) -> TokenStream { + derive_platform_deserialize(input, DecodeTrust::Untrusted) +} + +fn derive_platform_deserialize(input: TokenStream, trust: DecodeTrust) -> TokenStream { let cloned_token_stream_input = input.clone(); let input = parse_macro_input!(input as DeriveInput); @@ -321,6 +410,7 @@ pub fn derive_platform_deserialize(input: TokenStream) -> TokenStream { platform_serialize_limit, untagged, unversioned, + trust, platform_serialize_into, platform_version_path, allow_prepend_version, diff --git a/packages/rs-platform-value/src/lib.rs b/packages/rs-platform-value/src/lib.rs index d4ecf0ae08e..8239d58dbbb 100644 --- a/packages/rs-platform-value/src/lib.rs +++ b/packages/rs-platform-value/src/lib.rs @@ -181,131 +181,155 @@ fn validate_value_decode_depth(depth: usize) -> Result<(), DecodeError> { }) } -impl Decode for Value { - fn decode>(decoder: &mut D) -> Result { - let mut frames = Vec::::new(); - let mut completed_value = None; - - loop { - if let Some(value) = completed_value.take() { - let Some(frame) = frames.last_mut() else { - return Ok(value); - }; - - match frame { - ValueDecodeFrame::Array { values, remaining } => { - values.push(value); - *remaining -= 1; - - if *remaining == 0 { - let ValueDecodeFrame::Array { values, .. } = - frames.pop().expect("the array frame was just observed") - else { - unreachable!("the observed frame changed") - }; - completed_value = Some(Value::Array(values)); - } else { - decoder.unclaim_bytes_read(std::mem::size_of::()); +// Share the wire schema and domain checks across both decoding APIs. +macro_rules! impl_value_decode { + ($decode:ident, $decoder:ident, $method:ident, $untrusted:expr) => { + impl bincode::$decode for Value { + fn $method>( + decoder: &mut D, + ) -> Result { + let mut frames = Vec::::new(); + let mut completed_value = None; + + loop { + if let Some(value) = completed_value.take() { + let Some(frame) = frames.last_mut() else { + return Ok(value); + }; + + match frame { + ValueDecodeFrame::Array { values, remaining } => { + if $untrusted { + values + .try_reserve(1) + .map_err(|_| DecodeError::LimitExceeded)?; + } + values.push(value); + *remaining -= 1; + + if *remaining == 0 { + let ValueDecodeFrame::Array { values, .. } = + frames.pop().expect("the array frame was just observed") + else { + unreachable!("the observed frame changed") + }; + completed_value = Some(Value::Array(values)); + } else { + decoder.unclaim_bytes_read(std::mem::size_of::()); + } + } + ValueDecodeFrame::Map { + entries, + remaining, + pending_key, + } => { + if pending_key.is_none() { + *pending_key = Some(value); + } else { + let key = pending_key + .take() + .expect("the map frame was expecting a value"); + if $untrusted { + entries + .try_reserve(1) + .map_err(|_| DecodeError::LimitExceeded)?; + } + entries.push((key, value)); + *remaining -= 1; + + if *remaining == 0 { + let ValueDecodeFrame::Map { entries, .. } = + frames.pop().expect("the map frame was just observed") + else { + unreachable!("the observed frame changed") + }; + completed_value = Some(Value::Map(entries)); + } else { + decoder.unclaim_bytes_read(std::mem::size_of::<( + Value, + Value, + )>( + )); + } + } + } } + + continue; } - ValueDecodeFrame::Map { - entries, - remaining, - pending_key, - } => { - if pending_key.is_none() { - *pending_key = Some(value); - } else { - let key = pending_key - .take() - .expect("the map frame was expecting a value"); - entries.push((key, value)); - *remaining -= 1; - - if *remaining == 0 { - let ValueDecodeFrame::Map { entries, .. } = - frames.pop().expect("the map frame was just observed") - else { - unreachable!("the observed frame changed") - }; - completed_value = Some(Value::Map(entries)); + + let variant_index = >::$method(decoder)?; + completed_value = Some(match variant_index { + 0 => Value::U128(bincode::$decode::$method(decoder)?), + 1 => Value::I128(bincode::$decode::$method(decoder)?), + 2 => Value::U64(bincode::$decode::$method(decoder)?), + 3 => Value::I64(bincode::$decode::$method(decoder)?), + 4 => Value::U32(bincode::$decode::$method(decoder)?), + 5 => Value::I32(bincode::$decode::$method(decoder)?), + 6 => Value::U16(bincode::$decode::$method(decoder)?), + 7 => Value::I16(bincode::$decode::$method(decoder)?), + 8 => Value::U8(bincode::$decode::$method(decoder)?), + 9 => Value::I8(bincode::$decode::$method(decoder)?), + 10 => Value::Bytes(bincode::$decode::$method(decoder)?), + 11 => Value::Bytes20(bincode::$decode::$method(decoder)?), + 12 => Value::Bytes32(bincode::$decode::$method(decoder)?), + 13 => Value::Bytes36(bincode::$decode::$method(decoder)?), + 14 => Value::EnumU8(bincode::$decode::$method(decoder)?), + 15 => Value::EnumString(bincode::$decode::$method(decoder)?), + 16 => Value::Identifier(bincode::$decode::$method(decoder)?), + 17 => Value::Float(bincode::$decode::$method(decoder)?), + 18 => Value::Text(bincode::$decode::$method(decoder)?), + 19 => Value::Bool(bincode::$decode::$method(decoder)?), + 20 => Value::Null, + 21 => { + validate_value_decode_depth(frames.len() + 1)?; + let len = decode_value_container_len(decoder)?; + decoder.claim_container_read::(len)?; + + if len == 0 { + Value::Array(Vec::new()) } else { - decoder.unclaim_bytes_read(std::mem::size_of::<(Value, Value)>()); + frames.push(ValueDecodeFrame::Array { + values: Vec::with_capacity(if $untrusted { 0 } else { len }), + remaining: len, + }); + decoder.unclaim_bytes_read(std::mem::size_of::()); + continue; } } - } - } - - continue; - } + 22 => { + validate_value_decode_depth(frames.len() + 1)?; + let len = decode_value_container_len(decoder)?; + decoder.claim_container_read::<(Value, Value)>(len)?; - let variant_index = >::decode(decoder)?; - completed_value = Some(match variant_index { - 0 => Value::U128(Decode::decode(decoder)?), - 1 => Value::I128(Decode::decode(decoder)?), - 2 => Value::U64(Decode::decode(decoder)?), - 3 => Value::I64(Decode::decode(decoder)?), - 4 => Value::U32(Decode::decode(decoder)?), - 5 => Value::I32(Decode::decode(decoder)?), - 6 => Value::U16(Decode::decode(decoder)?), - 7 => Value::I16(Decode::decode(decoder)?), - 8 => Value::U8(Decode::decode(decoder)?), - 9 => Value::I8(Decode::decode(decoder)?), - 10 => Value::Bytes(Decode::decode(decoder)?), - 11 => Value::Bytes20(Decode::decode(decoder)?), - 12 => Value::Bytes32(Decode::decode(decoder)?), - 13 => Value::Bytes36(Decode::decode(decoder)?), - 14 => Value::EnumU8(Decode::decode(decoder)?), - 15 => Value::EnumString(Decode::decode(decoder)?), - 16 => Value::Identifier(Decode::decode(decoder)?), - 17 => Value::Float(Decode::decode(decoder)?), - 18 => Value::Text(Decode::decode(decoder)?), - 19 => Value::Bool(Decode::decode(decoder)?), - 20 => Value::Null, - 21 => { - validate_value_decode_depth(frames.len() + 1)?; - let len = decode_value_container_len(decoder)?; - decoder.claim_container_read::(len)?; - - if len == 0 { - Value::Array(Vec::new()) - } else { - frames.push(ValueDecodeFrame::Array { - values: Vec::with_capacity(len), - remaining: len, - }); - decoder.unclaim_bytes_read(std::mem::size_of::()); - continue; - } - } - 22 => { - validate_value_decode_depth(frames.len() + 1)?; - let len = decode_value_container_len(decoder)?; - decoder.claim_container_read::<(Value, Value)>(len)?; - - if len == 0 { - Value::Map(Vec::new()) - } else { - frames.push(ValueDecodeFrame::Map { - entries: Vec::with_capacity(len), - remaining: len, - pending_key: None, - }); - decoder.unclaim_bytes_read(std::mem::size_of::<(Value, Value)>()); - continue; - } - } - found => { - return Err(DecodeError::UnexpectedVariant { - type_name: std::any::type_name::(), - allowed: &AllowedEnumVariants::Range { min: 0, max: 22 }, - found, + if len == 0 { + Value::Map(Vec::new()) + } else { + frames.push(ValueDecodeFrame::Map { + entries: Vec::with_capacity(if $untrusted { 0 } else { len }), + remaining: len, + pending_key: None, + }); + decoder.unclaim_bytes_read(std::mem::size_of::<(Value, Value)>()); + continue; + } + } + found => { + return Err(DecodeError::UnexpectedVariant { + type_name: std::any::type_name::(), + allowed: &AllowedEnumVariants::Range { min: 0, max: 22 }, + found, + }); + } }); } - }); + } } - } + }; } +impl_value_decode!(Decode, Decoder, decode, false); +impl_value_decode!(DecodeUntrusted, UntrustedDecoder, decode_untrusted, true); +bincode::impl_borrow_decode_untrusted!(Value); bincode::impl_borrow_decode!(Value); diff --git a/packages/rs-platform-value/src/types/binary_data.rs b/packages/rs-platform-value/src/types/binary_data.rs index 92e79397e31..0d07ea5faff 100644 --- a/packages/rs-platform-value/src/types/binary_data.rs +++ b/packages/rs-platform-value/src/types/binary_data.rs @@ -3,12 +3,12 @@ use crate::types::encoding_string_to_encoding; use crate::{string_encoding, Error, Value}; use base64::prelude::BASE64_STANDARD; use base64::Engine; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::de::Visitor; use serde::{Deserialize, Serialize}; use std::fmt; -#[derive(Default, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Encode, Decode)] +#[derive(Default, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Encode, Decode, DecodeUntrusted)] pub struct BinaryData(pub Vec); impl fmt::Debug for BinaryData { diff --git a/packages/rs-platform-value/src/types/bytes_20.rs b/packages/rs-platform-value/src/types/bytes_20.rs index ce9d109cfc8..928fd3a6f33 100644 --- a/packages/rs-platform-value/src/types/bytes_20.rs +++ b/packages/rs-platform-value/src/types/bytes_20.rs @@ -3,12 +3,25 @@ use crate::types::encoding_string_to_encoding; use crate::{string_encoding, Error, Value}; use base64::prelude::BASE64_STANDARD; use base64::Engine; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::de::Visitor; use serde::{Deserialize, Serialize}; use std::fmt; -#[derive(Default, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Copy, Encode, Decode)] +#[derive( + Default, + Debug, + Clone, + PartialEq, + Eq, + Ord, + PartialOrd, + Hash, + Copy, + Encode, + Decode, + DecodeUntrusted, +)] pub struct Bytes20(pub [u8; 20]); impl AsRef<[u8]> for Bytes20 { diff --git a/packages/rs-platform-value/src/types/bytes_32.rs b/packages/rs-platform-value/src/types/bytes_32.rs index 3e9a1f63aa6..33d36bd84ff 100644 --- a/packages/rs-platform-value/src/types/bytes_32.rs +++ b/packages/rs-platform-value/src/types/bytes_32.rs @@ -3,14 +3,27 @@ use crate::types::encoding_string_to_encoding; use crate::{string_encoding, Error, Value}; use base64::prelude::BASE64_STANDARD; use base64::Engine; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use rand::rngs::StdRng; use rand::Rng; use serde::de::Visitor; use serde::{Deserialize, Serialize}; use std::fmt; -#[derive(Default, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Copy, Encode, Decode)] +#[derive( + Default, + Debug, + Clone, + PartialEq, + Eq, + Ord, + PartialOrd, + Hash, + Copy, + Encode, + Decode, + DecodeUntrusted, +)] pub struct Bytes32(pub [u8; 32]); impl AsRef<[u8]> for Bytes32 { diff --git a/packages/rs-platform-value/src/types/bytes_36.rs b/packages/rs-platform-value/src/types/bytes_36.rs index 00193c52a39..f56c49fece2 100644 --- a/packages/rs-platform-value/src/types/bytes_36.rs +++ b/packages/rs-platform-value/src/types/bytes_36.rs @@ -3,12 +3,14 @@ use crate::types::encoding_string_to_encoding; use crate::{string_encoding, Error, Value}; use base64::prelude::BASE64_STANDARD; use base64::Engine; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use serde::de::Visitor; use serde::{Deserialize, Serialize}; use std::fmt; -#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Copy, Encode, Decode)] +#[derive( + Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, Copy, Encode, Decode, DecodeUntrusted, +)] pub struct Bytes36(pub [u8; 36]); impl Bytes36 { diff --git a/packages/rs-platform-value/src/types/identifier.rs b/packages/rs-platform-value/src/types/identifier.rs index 5335e069576..1e37e578ca9 100644 --- a/packages/rs-platform-value/src/types/identifier.rs +++ b/packages/rs-platform-value/src/types/identifier.rs @@ -1,6 +1,6 @@ use bincode::enc::Encoder; use bincode::error::EncodeError; -use bincode::{Decode, Encode}; +use bincode::{Decode, DecodeUntrusted, Encode}; use rand::distributions::Standard; use rand::prelude::Distribution; use rand::rngs::StdRng; @@ -18,7 +18,20 @@ use crate::{string_encoding, Error, Value}; pub const IDENTIFIER_MEDIA_TYPE: &str = "application/x.dash.dpp.identifier"; -#[derive(Default, Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, Copy, Encode, Decode)] +#[derive( + Default, + Debug, + Clone, + PartialEq, + Eq, + Hash, + Ord, + PartialOrd, + Copy, + Encode, + Decode, + DecodeUntrusted, +)] pub struct IdentifierBytes32(pub [u8; 32]); #[derive( @@ -35,6 +48,7 @@ pub struct IdentifierBytes32(pub [u8; 32]); Deserialize, Encode, Decode, + DecodeUntrusted, )] pub struct Identifier(pub IdentifierBytes32); diff --git a/packages/rs-platform-value/tests/untrusted_decode.rs b/packages/rs-platform-value/tests/untrusted_decode.rs new file mode 100644 index 00000000000..91ce1c0601b --- /dev/null +++ b/packages/rs-platform-value/tests/untrusted_decode.rs @@ -0,0 +1,116 @@ +use bincode::config; +use platform_value::Value; +use std::alloc::{GlobalAlloc, Layout, System}; +use std::cell::Cell; + +struct ObservedAllocator; + +thread_local! { + static OBSERVING: Cell = const { Cell::new(false) }; + static LARGEST_REQUEST: Cell = const { Cell::new(0) }; +} + +fn observe(size: usize) { + let _ = OBSERVING.try_with(|enabled| { + if enabled.get() { + LARGEST_REQUEST.with(|largest| largest.set(largest.get().max(size))); + } + }); +} + +unsafe impl GlobalAlloc for ObservedAllocator { + unsafe fn alloc(&self, layout: Layout) -> *mut u8 { + observe(layout.size()); + unsafe { System.alloc(layout) } + } + + unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 { + observe(layout.size()); + unsafe { System.alloc_zeroed(layout) } + } + + unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, size: usize) -> *mut u8 { + observe(size); + unsafe { System.realloc(ptr, layout, size) } + } + + unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { + unsafe { System.dealloc(ptr, layout) } + } +} + +#[global_allocator] +static ALLOCATOR: ObservedAllocator = ObservedAllocator; + +#[test] +fn should_reject_missing_value_payload_without_reserving_declared_lengths() { + let config = config::standard().with_big_endian().with_no_limit(); + // Bytes, enum bytes/strings, text, arrays and maps all allocate. Include + // arrays/maps with one complete entry before the missing remainder. + for variant in [10u32, 14, 15, 18, 21, 22] { + let mut bytes = bincode::encode_to_vec(variant, config).unwrap(); + bytes.extend(bincode::encode_to_vec(262_144u64, config).unwrap()); + if variant == 21 { + bytes.extend(bincode::encode_to_vec(Value::Null, config).unwrap()); + } else if variant == 22 { + bytes.extend(bincode::encode_to_vec((Value::Null, Value::Null), config).unwrap()); + } + + LARGEST_REQUEST.with(|largest| largest.set(0)); + OBSERVING.with(|enabled| enabled.set(true)); + let owned = bincode::decode_from_slice_untrusted::(&bytes, config); + let borrowed = bincode::borrow_decode_from_slice_untrusted::(&bytes, config); + OBSERVING.with(|enabled| enabled.set(false)); + let largest = LARGEST_REQUEST.with(Cell::get); + + assert!(owned.is_err() && borrowed.is_err(), "variant {variant}"); + assert!( + largest < 16_384, + "variant {variant} reserved {largest} bytes" + ); + } +} + +#[test] +fn should_preserve_value_wire_format_and_consumed_bytes() { + let value = Value::Map(vec![ + (Value::Text("key".into()), Value::Bytes(vec![0, 1, 255])), + ( + Value::U64(u64::MAX), + Value::Array(vec![Value::Null, Value::EnumString(vec!["choice".into()])]), + ), + ]); + macro_rules! check { + ($config:expr) => {{ + let mut bytes = bincode::encode_to_vec(&value, $config).unwrap(); + let consumed = bytes.len(); + bytes.push(42); + let ordinary = bincode::decode_from_slice::(&bytes, $config).unwrap(); + let guarded = + bincode::decode_from_slice_untrusted::(&bytes, $config).unwrap(); + let borrowed = + bincode::borrow_decode_from_slice_untrusted::(&bytes, $config).unwrap(); + assert_eq!(ordinary, (value.clone(), consumed)); + assert_eq!(guarded, ordinary); + assert_eq!(borrowed, ordinary); + }}; + } + check!(config::standard()); + check!(config::standard().with_big_endian()); + check!(config::standard().with_fixed_int_encoding()); + check!(config::standard() + .with_big_endian() + .with_fixed_int_encoding()); +} + +#[test] +fn should_preserve_value_depth_and_budget_checks() { + let config = config::standard().with_big_endian(); + let mut bytes = [21, 1].repeat(1_000); + bytes.push(20); // Null at the bottom of the nested arrays. + assert!(bincode::decode_from_slice_untrusted::(&bytes, config).is_err()); + let bytes = bincode::encode_to_vec(Value::Bytes(vec![1; 32]), config).unwrap(); + assert!( + bincode::decode_from_slice_untrusted::(&bytes, config.with_limit::<8>()).is_err() + ); +} diff --git a/packages/rs-platform-wallet-ffi/src/asset_lock/sync.rs b/packages/rs-platform-wallet-ffi/src/asset_lock/sync.rs index 5e930e11dca..80b739f2435 100644 --- a/packages/rs-platform-wallet-ffi/src/asset_lock/sync.rs +++ b/packages/rs-platform-wallet-ffi/src/asset_lock/sync.rs @@ -365,7 +365,7 @@ pub unsafe extern "C" fn asset_lock_manager_recover( // 16 MiB is generous while matching the persisted-blob ceiling. unwrap_result_or_return!(validate_asset_lock_proof_size(proof_len)); let data = std::slice::from_raw_parts(proof_bytes, proof_len); - let (p, _) = unwrap_result_or_return!(dpp::bincode::decode_from_slice( + let (p, _) = unwrap_result_or_return!(dpp::bincode::decode_from_slice_untrusted( data, dpp::bincode::config::standard().with_limit::() )); diff --git a/packages/rs-platform-wallet-ffi/src/core_wallet/transaction_builder.rs b/packages/rs-platform-wallet-ffi/src/core_wallet/transaction_builder.rs index 08e876f896d..bb3f8f3d6dc 100644 --- a/packages/rs-platform-wallet-ffi/src/core_wallet/transaction_builder.rs +++ b/packages/rs-platform-wallet-ffi/src/core_wallet/transaction_builder.rs @@ -891,26 +891,30 @@ pub unsafe extern "C" fn core_wallet_tx_builder_set_special_payload( check_ptr!(payload_bytes); let bytes = std::slice::from_raw_parts(payload_bytes, payload_len); - let payload: TransactionPayload = - match bincode::decode_from_slice(bytes, bincode::config::standard()) { - Ok((p, consumed)) => { - if consumed != payload_len { - return PlatformWalletFFIResult::err( - PlatformWalletFFIResultCode::ErrorDeserialization, - format!( - "trailing bytes after payload: decoded {consumed} of {payload_len} bytes" - ), - ); - } - p - } - Err(e) => { + // Upstream TransactionPayload does not implement DecodeUntrusted yet. + // Its derived decoders can reserve collections from their length headers, + // so use Core's existing decode limit until those decoders opt in. + let config = + bincode::config::standard().with_limit::<{ dashcore::consensus::encode::MAX_VEC_SIZE }>(); + let payload: TransactionPayload = match bincode::decode_from_slice(bytes, config) { + Ok((p, consumed)) => { + if consumed != payload_len { return PlatformWalletFFIResult::err( PlatformWalletFFIResultCode::ErrorDeserialization, - format!("invalid special payload: {e}"), + format!( + "trailing bytes after payload: decoded {consumed} of {payload_len} bytes" + ), ); } - }; + p + } + Err(e) => { + return PlatformWalletFFIResult::err( + PlatformWalletFFIResultCode::ErrorDeserialization, + format!("invalid special payload: {e}"), + ); + } + }; let b = (*builder).take_builder(); let b = b.set_special_payload(payload); @@ -1041,6 +1045,50 @@ pub unsafe extern "C" fn core_wallet_transaction_free(tx: *mut FFICoreTransactio tx.tx_len = 0; } +#[cfg(test)] +mod payload_decode_tests { + use super::*; + use dashcore::blockdata::transaction::special_transaction::asset_lock::AssetLockPayload; + use std::ffi::CStr; + + #[test] + fn should_reject_unbounded_payload_collection_and_keep_builder_usable() { + let payload = TransactionPayload::AssetLockPayloadType(AssetLockPayload::new(vec![])); + let valid = bincode::encode_to_vec(payload, bincode::config::standard()) + .expect("encode an asset lock payload"); + let mut malformed = valid.clone(); + // Replace the empty credit_outputs count with an oversized declaration, + // without supplying any output bytes. + assert_eq!(malformed.pop(), Some(0)); + malformed.extend( + bincode::encode_to_vec(u64::MAX, bincode::config::standard()) + .expect("encode a collection length"), + ); + + unsafe { + let builder = core_wallet_tx_builder_new(FFINetwork::Testnet); + let rejected = core_wallet_tx_builder_set_special_payload( + builder, + malformed.as_ptr(), + malformed.len(), + ); + let accepted = + core_wallet_tx_builder_set_special_payload(builder, valid.as_ptr(), valid.len()); + core_wallet_tx_builder_destroy(builder); + + assert_eq!( + rejected.code, + PlatformWalletFFIResultCode::ErrorDeserialization + ); + assert!(CStr::from_ptr(rejected.message) + .to_str() + .expect("UTF-8 error message") + .contains("LimitExceeded")); + assert_eq!(accepted.code, PlatformWalletFFIResultCode::Success); + } + } +} + #[cfg(test)] mod pooled_balance_handle_tests { //! The two pooled-balance entry points are exposed on the *core* wallet diff --git a/packages/rs-platform-wallet-ffi/src/managed_identity.rs b/packages/rs-platform-wallet-ffi/src/managed_identity.rs index 71e7c7544ee..fb76678e508 100644 --- a/packages/rs-platform-wallet-ffi/src/managed_identity.rs +++ b/packages/rs-platform-wallet-ffi/src/managed_identity.rs @@ -4,7 +4,7 @@ use crate::types::*; use crate::{check_ptr, deref_ptr, unwrap_option_or_return, unwrap_result_or_return}; use dpp::identity::accessors::IdentityGettersV0; use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use platform_wallet::ManagedIdentity; use std::os::raw::c_char; @@ -21,7 +21,7 @@ pub unsafe extern "C" fn managed_identity_create_from_identity_bytes( let bytes = unsafe { std::slice::from_raw_parts(identity_bytes, identity_len) }; let identity = unwrap_result_or_return!( - dpp::identity::Identity::deserialize_from_bytes_no_limit(bytes) + dpp::identity::Identity::deserialize_from_bytes_untrusted_no_limit(bytes) ); let managed_identity = ManagedIdentity::new(identity, 0); diff --git a/packages/rs-platform-wallet-ffi/src/parse_state_transition.rs b/packages/rs-platform-wallet-ffi/src/parse_state_transition.rs index 409102f051c..2460dfaf975 100644 --- a/packages/rs-platform-wallet-ffi/src/parse_state_transition.rs +++ b/packages/rs-platform-wallet-ffi/src/parse_state_transition.rs @@ -20,7 +20,7 @@ use std::borrow::Cow; use std::slice; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0; use dpp::state_transition::batch_transition::batched_transition::token_transition::TokenTransition; use dpp::state_transition::batch_transition::batched_transition::BatchedTransitionRef; @@ -139,7 +139,7 @@ pub(crate) fn deserialize_transition_with_flexible_framing( let mut failures: Vec = Vec::with_capacity(attempts.len()); for (payload, label) in &attempts { - match StateTransition::deserialize_from_bytes(payload) { + match StateTransition::deserialize_from_bytes_untrusted(payload) { Ok(state_transition) => return Ok(state_transition), Err(error) => failures.push(format!("{label}: {error}")), } diff --git a/packages/rs-platform-wallet-ffi/src/persistence.rs b/packages/rs-platform-wallet-ffi/src/persistence.rs index 58d23b95bf7..ef76a9d87fd 100644 --- a/packages/rs-platform-wallet-ffi/src/persistence.rs +++ b/packages/rs-platform-wallet-ffi/src/persistence.rs @@ -92,6 +92,14 @@ use std::ffi::CStr; pub(crate) const TX_CONTEXT_RAW_IN_BLOCK: u32 = 2; pub(crate) const TX_CONTEXT_RAW_IN_CHAIN_LOCKED_BLOCK: u32 = 3; +/// Byte budget for decoding a host-supplied account extended public key. +/// +/// The upstream `key-wallet` xpub decoders do not implement +/// `DecodeUntrusted`, so every decode of persisted `account_xpub_bytes` +/// (ECDSA, BLS, EdDSA) runs under this explicit limit instead; a complete +/// xpub of any of the three kinds is under 200 bytes. +pub(crate) const ACCOUNT_XPUB_DECODE_LIMIT_BYTES: usize = 1024; + /// Versioned C projection of [`PersistenceCapabilities`]. /// /// `version` identifies the stable bit assignment. `reserved` must be ignored @@ -5031,21 +5039,22 @@ fn build_wallet_start_state( // and show stale operator / platform-node keys until it's deleted // and re-imported — an accepted, transient dev-only state. // - // INTENTIONAL(unmaintained-bincode-decoder): the three account-xpub - // decodes below run bincode 2.0.1 (RUSTSEC-2025-0141: development - // ceased, no CVE, no fix version) over host-supplied bytes. Accepted: - // no defect today, and the migration is tracked as its own - // supply-chain item, to be paired with the trailing-byte validation - // the `flush` decode boundary already defers. + // The three account-xpub decodes below run upstream `key-wallet` + // decoders that do not implement `DecodeUntrusted` over host-supplied + // bytes, so each one carries the explicit + // `ACCOUNT_XPUB_DECODE_LIMIT_BYTES` budget. Trailing bytes are still + // ignored, the same deferral as the `flush` decode boundary. match account_type { AccountType::ProviderOperatorKeys => { - let (bls_pubkey, _): (ExtendedBLSPubKey, usize) = - bincode::decode_from_slice(xpub_bytes, config::standard()).map_err(|e| { - PersistenceError::backend(format!( - "failed to decode provider BLS xpub: {}", - e - )) - })?; + // The BLS decoder reads a Vec before validating the public + // key, so the budget is what bounds its allocation. + let (bls_pubkey, _): (ExtendedBLSPubKey, usize) = bincode::decode_from_slice( + xpub_bytes, + config::standard().with_limit::(), + ) + .map_err(|e| { + PersistenceError::backend(format!("failed to decode provider BLS xpub: {}", e)) + })?; let bls_account = BLSAccount::new( Some(entry.wallet_id.to_vec()), account_type, @@ -5064,13 +5073,16 @@ fn build_wallet_start_state( continue; } AccountType::ProviderPlatformKeys => { - let (ed_pubkey, _): (ExtendedEd25519PubKey, usize) = - bincode::decode_from_slice(xpub_bytes, config::standard()).map_err(|e| { - PersistenceError::backend(format!( - "failed to decode provider EdDSA xpub: {}", - e - )) - })?; + let (ed_pubkey, _): (ExtendedEd25519PubKey, usize) = bincode::decode_from_slice( + xpub_bytes, + config::standard().with_limit::(), + ) + .map_err(|e| { + PersistenceError::backend(format!( + "failed to decode provider EdDSA xpub: {}", + e + )) + })?; let eddsa_account = EdDSAAccount::new( Some(entry.wallet_id.to_vec()), account_type, @@ -5096,10 +5108,11 @@ fn build_wallet_start_state( _ => {} } - let (account_xpub, _): (ExtendedPubKey, usize) = - bincode::decode_from_slice(xpub_bytes, config::standard()).map_err(|e| { - PersistenceError::backend(format!("failed to decode account xpub: {}", e)) - })?; + let (account_xpub, _): (ExtendedPubKey, usize) = bincode::decode_from_slice( + xpub_bytes, + config::standard().with_limit::(), + ) + .map_err(|e| PersistenceError::backend(format!("failed to decode account xpub: {}", e)))?; let account = Account::from_xpub(Some(entry.wallet_id), account_type, account_xpub, network) .map_err(|e| { @@ -5695,10 +5708,8 @@ fn build_unused_asset_locks( // SAFETY: Same lifetime contract as `transaction_bytes`. let proof_bytes = unsafe { slice::from_raw_parts(spec.proof_bytes, spec.proof_bytes_len) }; - // INTENTIONAL(unmaintained-bincode-decoder): host-supplied bytes - // through bincode 2.0.1 (RUSTSEC-2025-0141, unmaintained). Same - // accepted risk as the account-xpub decodes in - // `build_wallet_start_state`. + // The host persisted these bytes from an entry this wallet + // wrote, so they decode as our own data. let (proof, _) = dpp::bincode::decode_from_slice::( proof_bytes, config::standard(), @@ -8997,8 +9008,11 @@ mod tests { let restored_type = account_type_from_spec(&spec).expect("account type tag round-trips through the spec"); let raw = unsafe { slice_from_raw(spec.account_xpub_bytes, spec.account_xpub_bytes_len) }; - let (decoded_xpub, _): (ExtendedPubKey, usize) = - bincode::decode_from_slice(raw, config::standard()).expect("decode account xpub"); + let (decoded_xpub, _): (ExtendedPubKey, usize) = bincode::decode_from_slice( + raw, + config::standard().with_limit::(), + ) + .expect("decode account xpub"); assert_eq!( decoded_xpub, expected_xpub, "the bincode round-trip must preserve the account xpub byte-for-byte" @@ -9016,6 +9030,41 @@ mod tests { ); } + /// The BLS xpub decoder is the only account-xpub graph with a + /// length-prefixed field (the public key bytes). A host-supplied blob + /// whose prefix claims a gigabyte must fail on the decode budget, before + /// the decoder reserves memory for the claimed payload. + #[test] + fn should_reject_inflated_bls_xpub_length_under_the_decode_budget() { + use key_wallet::bip32::ChildNumber; + + // network, depth, parent fingerprint, child number: the fixed-width + // header every extended key starts with. + let mut bytes = bincode::encode_to_vec( + ( + Network::Testnet, + 0u8, + [0u8; 4], + ChildNumber::Normal { index: 0 }, + ), + config::standard(), + ) + .expect("encode xpub header"); + // Vec length prefix claiming 1 GiB (bincode varint u32 marker), + // followed by a single byte of payload. + bytes.extend_from_slice(&[0xFC, 0x00, 0x00, 0x00, 0x40, 0x00]); + + let error = bincode::decode_from_slice::( + &bytes, + config::standard().with_limit::(), + ) + .expect_err("a BLS xpub claiming a 1 GiB public key must not decode"); + assert!( + matches!(error, bincode::error::DecodeError::LimitExceeded), + "the decode budget must reject the claimed length, got {error:?}" + ); + } + /// Helper: a minimum valid consensus-encodable transaction — /// version 1, one synthetic input, one zero-value output. The /// restoration helper only cares that the bytes round-trip diff --git a/packages/rs-platform-wallet-ffi/src/xpub_render.rs b/packages/rs-platform-wallet-ffi/src/xpub_render.rs index a92f8ce17ed..c20363a48e8 100644 --- a/packages/rs-platform-wallet-ffi/src/xpub_render.rs +++ b/packages/rs-platform-wallet-ffi/src/xpub_render.rs @@ -9,6 +9,7 @@ use std::os::raw::c_char; use std::ptr; use crate::error::{PlatformWalletFFIResult, PlatformWalletFFIResultCode}; +use crate::persistence::ACCOUNT_XPUB_DECODE_LIMIT_BYTES; use crate::{check_ptr, unwrap_result_or_return}; /// Decode a bincode-encoded `ExtendedPubKey` (as emitted by @@ -36,9 +37,11 @@ pub unsafe extern "C" fn platform_wallet_account_xpub_to_string( *out_string = ptr::null_mut(); let slice = std::slice::from_raw_parts(bytes, bytes_len); - let (xpub, _): (ExtendedPubKey, usize) = unwrap_result_or_return!( - bincode::decode_from_slice::(slice, config::standard()) - ); + let (xpub, _): (ExtendedPubKey, usize) = + unwrap_result_or_return!(bincode::decode_from_slice::( + slice, + config::standard().with_limit::() + )); let cstring = unwrap_result_or_return!(CString::new(xpub.to_string())); *out_string = cstring.into_raw(); diff --git a/packages/rs-platform-wallet/src/wallet/shielded/activity_recorder.rs b/packages/rs-platform-wallet/src/wallet/shielded/activity_recorder.rs index 2a812312f33..a24a953d741 100644 --- a/packages/rs-platform-wallet/src/wallet/shielded/activity_recorder.rs +++ b/packages/rs-platform-wallet/src/wallet/shielded/activity_recorder.rs @@ -36,7 +36,7 @@ use super::keys::AccountViewingKeys; use super::store::{PendingRedrive, ShieldedNote, SubwalletId}; use crate::changeset::ShieldedChangeSet; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::shielded::SerializedAction; use dpp::state_transition::shield_from_identity_transition::accessors::ShieldFromIdentityTransitionAccessorsV0; use dpp::state_transition::StateTransition; @@ -60,7 +60,7 @@ pub(super) fn identity_redrive_output_cmxs( "not an identity debit".to_owned(), )); } - let transition = StateTransition::deserialize_from_bytes(&redrive.st_bytes) + let transition = StateTransition::deserialize_from_bytes_trusted(&redrive.st_bytes) .map_err(|e| IdentityRecoveryError::Malformed(format!("invalid signed transition: {e}")))?; let StateTransition::ShieldFromIdentity(transition) = transition else { return Err(IdentityRecoveryError::Malformed( diff --git a/packages/rs-platform-wallet/src/wallet/shielded/coordinator.rs b/packages/rs-platform-wallet/src/wallet/shielded/coordinator.rs index 3d447ae4b40..34eee1e05cf 100644 --- a/packages/rs-platform-wallet/src/wallet/shielded/coordinator.rs +++ b/packages/rs-platform-wallet/src/wallet/shielded/coordinator.rs @@ -91,7 +91,7 @@ use crate::error::PlatformWalletError; use crate::manager::shielded_sync::{ShieldedSyncPassSummary, WalletShieldedOutcome}; use crate::wallet::persister::WalletPersister; use crate::wallet::platform_wallet::WalletId; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableTrusted; use dpp::state_transition::shield_from_identity_transition::accessors::ShieldFromIdentityTransitionAccessorsV0; use dpp::state_transition::StateTransition; @@ -535,10 +535,11 @@ impl NetworkShieldedCoordinator { .into_iter() .filter(|(_, record)| record.nullifiers.is_empty()) .map(|(id, record)| { - let transition = match StateTransition::deserialize_from_bytes(&record.st_bytes) { - Ok(StateTransition::ShieldFromIdentity(transition)) => Some(transition), - _ => None, - }; + let transition = + match StateTransition::deserialize_from_bytes_trusted(&record.st_bytes) { + Ok(StateTransition::ShieldFromIdentity(transition)) => Some(transition), + _ => None, + }; IdentityDebitRecoveryRecord { account_index: id.account_index, activity_id: record.activity_id, diff --git a/packages/rs-platform-wallet/src/wallet/shielded/file_store.rs b/packages/rs-platform-wallet/src/wallet/shielded/file_store.rs index 365419bd1c4..393e4db2b28 100644 --- a/packages/rs-platform-wallet/src/wallet/shielded/file_store.rs +++ b/packages/rs-platform-wallet/src/wallet/shielded/file_store.rs @@ -17,7 +17,7 @@ use std::fmt; use std::path::{Path, PathBuf}; use std::sync::Mutex; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableTrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use grovedb_commitment_tree::{ClientPersistentCommitmentTree, Position, Retention}; @@ -284,7 +284,7 @@ impl FileBackedShieldedStore { // because its active recovery flags are both false. if !nullifiers.is_empty() && matches!( - StateTransition::deserialize_from_bytes(&st_bytes), + StateTransition::deserialize_from_bytes_trusted(&st_bytes), Ok(StateTransition::ShieldFromIdentity(_)) ) { @@ -348,7 +348,7 @@ impl FileBackedShieldedStore { /// note nullifiers. A complete outer transition decode is required so /// corrupt, unknown, or identity-funded bytes remain fail-closed. fn non_identity_note_spend_kind(st_bytes: &[u8]) -> Option<&'static str> { - let state_transition = StateTransition::deserialize_from_bytes(st_bytes).ok()?; + let state_transition = StateTransition::deserialize_from_bytes_trusted(st_bytes).ok()?; if state_transition.serialize_to_bytes().ok()?.as_slice() != st_bytes { return None; } diff --git a/packages/rs-platform-wallet/src/wallet/shielded/operations.rs b/packages/rs-platform-wallet/src/wallet/shielded/operations.rs index 5775f8eb62b..0eda804a40d 100644 --- a/packages/rs-platform-wallet/src/wallet/shielded/operations.rs +++ b/packages/rs-platform-wallet/src/wallet/shielded/operations.rs @@ -813,14 +813,14 @@ fn has_unresolved_identity_shield( wallet_id: WalletId, identity_id: [u8; 32], ) -> Result { - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableTrusted; use dpp::state_transition::shield_from_identity_transition::accessors::ShieldFromIdentityTransitionAccessorsV0; for (_, redrive) in store.pending_redrives_for_wallet(wallet_id)? { if redrive.identity_user_abandoned && redrive.nullifiers.is_empty() { continue; } - match StateTransition::deserialize_from_bytes(&redrive.st_bytes) { + match StateTransition::deserialize_from_bytes_trusted(&redrive.st_bytes) { Ok(StateTransition::ShieldFromIdentity(transition)) if transition.identity_id().to_buffer() == identity_id => { @@ -3054,7 +3054,7 @@ pub(super) async fn redrive_pending_identity_shields( store: &Arc>, wallet_id: WalletId, ) { - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableTrusted; use dpp::state_transition::shield_from_identity_transition::accessors::ShieldFromIdentityTransitionAccessorsV0; let redrives = match store.read().await.pending_redrives_for_wallet(wallet_id) { @@ -3071,13 +3071,14 @@ pub(super) async fn redrive_pending_identity_shields( { continue; } - let state_transition = match StateTransition::deserialize_from_bytes(&redrive.st_bytes) { - Ok(state_transition @ StateTransition::ShieldFromIdentity(_)) => state_transition, - _ => { - warn!("identity redrive: unreadable debit; retaining its retry guard"); - continue; - } - }; + let state_transition = + match StateTransition::deserialize_from_bytes_trusted(&redrive.st_bytes) { + Ok(state_transition @ StateTransition::ShieldFromIdentity(_)) => state_transition, + _ => { + warn!("identity redrive: unreadable debit; retaining its retry guard"); + continue; + } + }; let StateTransition::ShieldFromIdentity(identity_transition) = &state_transition else { continue; }; @@ -3158,7 +3159,7 @@ pub(super) async fn redrive_pending_spends( id: SubwalletId, recorded: &std::collections::HashSet<[u8; 32]>, ) { - use dpp::serialization::PlatformDeserializable; + use dpp::serialization::PlatformDeserializableTrusted; let redrives = match store.read().await.pending_redrives(id) { Ok(r) => r, @@ -3181,7 +3182,7 @@ pub(super) async fn redrive_pending_spends( if !recorded.contains(&redrive.anchor) || redrive.attempts >= MAX_REDRIVE_ATTEMPTS { continue; } - let st = match StateTransition::deserialize_from_bytes(&redrive.st_bytes) { + let st = match StateTransition::deserialize_from_bytes_trusted(&redrive.st_bytes) { Ok(st) => st, Err(e) => { warn!( diff --git a/packages/rs-sdk-ffi/src/address/mod.rs b/packages/rs-sdk-ffi/src/address/mod.rs index ed96a5fed21..978e58d0b0f 100644 --- a/packages/rs-sdk-ffi/src/address/mod.rs +++ b/packages/rs-sdk-ffi/src/address/mod.rs @@ -174,7 +174,8 @@ pub unsafe extern "C" fn dash_sdk_format_grovedb_proof( .with_big_endian() .with_limit::<{ 256 * 1024 * 1024 }>(); - let grovedb_proof: GroveDBProof = match bincode::decode_from_slice(bytes, config) { + let grovedb_proof: GroveDBProof = match bincode::decode_from_slice_untrusted(bytes, config) + { Ok((proof, _)) => proof, Err(e) => { return DashSDKResult::error(DashSDKError::new( diff --git a/packages/rs-sdk-ffi/src/sdk.rs b/packages/rs-sdk-ffi/src/sdk.rs index 0f3f89b666b..e0eaee863a0 100644 --- a/packages/rs-sdk-ffi/src/sdk.rs +++ b/packages/rs-sdk-ffi/src/sdk.rs @@ -4,7 +4,7 @@ use std::sync::{Arc, OnceLock}; use tokio::runtime::Runtime; use tracing::{debug, error, info, warn}; -use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dash_sdk::sdk::AddressList; use dash_sdk::{Sdk, SdkBuilder}; use std::ffi::CStr; @@ -743,7 +743,7 @@ pub unsafe extern "C" fn dash_sdk_add_known_contracts( // Deserialize the contract using DPP let platform_version = wrapper.sdk.version(); - match dash_sdk::dpp::data_contract::DataContract::versioned_deserialize( + match dash_sdk::dpp::data_contract::DataContract::versioned_deserialize_untrusted( contract_data, false, // don't validate (we trust the data) platform_version, diff --git a/packages/rs-sdk-ffi/src/token/burn.rs b/packages/rs-sdk-ffi/src/token/burn.rs index 3e5c344ded0..bcba8225203 100644 --- a/packages/rs-sdk-ffi/src/token/burn.rs +++ b/packages/rs-sdk-ffi/src/token/burn.rs @@ -123,9 +123,9 @@ pub unsafe extern "C" fn dash_sdk_token_burn( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/claim.rs b/packages/rs-sdk-ffi/src/token/claim.rs index b32d3d23732..9f0717f61b8 100644 --- a/packages/rs-sdk-ffi/src/token/claim.rs +++ b/packages/rs-sdk-ffi/src/token/claim.rs @@ -125,9 +125,9 @@ pub unsafe extern "C" fn dash_sdk_token_claim( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/config_update.rs b/packages/rs-sdk-ffi/src/token/config_update.rs index 4e173a784e6..5a8c6885d23 100644 --- a/packages/rs-sdk-ffi/src/token/config_update.rs +++ b/packages/rs-sdk-ffi/src/token/config_update.rs @@ -137,9 +137,9 @@ pub unsafe extern "C" fn dash_sdk_token_update_contract_token_configuration( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/destroy_frozen_funds.rs b/packages/rs-sdk-ffi/src/token/destroy_frozen_funds.rs index 627de80cf26..c85d0cb8efd 100644 --- a/packages/rs-sdk-ffi/src/token/destroy_frozen_funds.rs +++ b/packages/rs-sdk-ffi/src/token/destroy_frozen_funds.rs @@ -135,9 +135,9 @@ pub unsafe extern "C" fn dash_sdk_token_destroy_frozen_funds( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/emergency_action.rs b/packages/rs-sdk-ffi/src/token/emergency_action.rs index 1cf00009b07..3f75fa7942a 100644 --- a/packages/rs-sdk-ffi/src/token/emergency_action.rs +++ b/packages/rs-sdk-ffi/src/token/emergency_action.rs @@ -126,9 +126,9 @@ pub unsafe extern "C" fn dash_sdk_token_emergency_action( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/freeze.rs b/packages/rs-sdk-ffi/src/token/freeze.rs index d53f21dcdd2..d91939717d8 100644 --- a/packages/rs-sdk-ffi/src/token/freeze.rs +++ b/packages/rs-sdk-ffi/src/token/freeze.rs @@ -138,9 +138,9 @@ pub unsafe extern "C" fn dash_sdk_token_freeze( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/mint.rs b/packages/rs-sdk-ffi/src/token/mint.rs index bc955541c76..e78585c5835 100644 --- a/packages/rs-sdk-ffi/src/token/mint.rs +++ b/packages/rs-sdk-ffi/src/token/mint.rs @@ -216,9 +216,9 @@ pub unsafe extern "C" fn dash_sdk_token_mint( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/purchase.rs b/packages/rs-sdk-ffi/src/token/purchase.rs index 14e3847234e..69631ab48c9 100644 --- a/packages/rs-sdk-ffi/src/token/purchase.rs +++ b/packages/rs-sdk-ffi/src/token/purchase.rs @@ -131,9 +131,9 @@ pub unsafe extern "C" fn dash_sdk_token_purchase( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/set_price.rs b/packages/rs-sdk-ffi/src/token/set_price.rs index fd527b10cb8..07791eabde7 100644 --- a/packages/rs-sdk-ffi/src/token/set_price.rs +++ b/packages/rs-sdk-ffi/src/token/set_price.rs @@ -146,9 +146,9 @@ pub unsafe extern "C" fn dash_sdk_token_set_price( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/transfer.rs b/packages/rs-sdk-ffi/src/token/transfer.rs index 8a240b10c83..1425ecd28c6 100644 --- a/packages/rs-sdk-ffi/src/token/transfer.rs +++ b/packages/rs-sdk-ffi/src/token/transfer.rs @@ -136,9 +136,9 @@ pub unsafe extern "C" fn dash_sdk_token_transfer( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk-ffi/src/token/unfreeze.rs b/packages/rs-sdk-ffi/src/token/unfreeze.rs index fb20cf1cda5..e2f47f143a7 100644 --- a/packages/rs-sdk-ffi/src/token/unfreeze.rs +++ b/packages/rs-sdk-ffi/src/token/unfreeze.rs @@ -135,9 +135,9 @@ pub unsafe extern "C" fn dash_sdk_token_unfreeze( ) }; - use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; + use dash_sdk::dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; - DataContract::versioned_deserialize( + DataContract::versioned_deserialize_untrusted( contract_slice, false, // skip validation since it's already validated wrapper.sdk.version(), diff --git a/packages/rs-sdk/src/error.rs b/packages/rs-sdk/src/error.rs index cc8309ebcd4..2254324cc62 100644 --- a/packages/rs-sdk/src/error.rs +++ b/packages/rs-sdk/src/error.rs @@ -9,7 +9,7 @@ use dpp::consensus::basic::state_transition::{ }; use dpp::consensus::state::address_funds::{AddressDoesNotExistError, AddressNotEnoughFundsError}; use dpp::consensus::ConsensusError; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::validation::SimpleConsensusValidationResult; use dpp::version::PlatformVersionError; use dpp::{dashcore_rpc, ProtocolError}; @@ -160,8 +160,8 @@ impl TryFrom for StateTransitionBroadcastErr fn try_from(value: StateTransitionBroadcastErrorProto) -> Result { let cause = if !value.data.is_empty() { - let consensus_error = - ConsensusError::deserialize_from_bytes(&value.data).map_err(|e| { + let consensus_error = ConsensusError::deserialize_from_bytes_untrusted(&value.data) + .map_err(|e| { tracing::debug!("Failed to deserialize consensus error: {}", e); Error::Protocol(e) @@ -192,7 +192,7 @@ impl From for Error { return consensus_error_value .to_bytes() .map(|bytes| { - ConsensusError::deserialize_from_bytes(&bytes) + ConsensusError::deserialize_from_bytes_untrusted(&bytes) .map(|consensus_error| { Self::Protocol(ProtocolError::ConsensusError(Box::new( consensus_error, diff --git a/packages/rs-sdk/src/mock/requests.rs b/packages/rs-sdk/src/mock/requests.rs index 9fb2a674911..4115178e19a 100644 --- a/packages/rs-sdk/src/mock/requests.rs +++ b/packages/rs-sdk/src/mock/requests.rs @@ -19,7 +19,7 @@ use dpp::{ platform_serialization::{platform_encode_to_vec, platform_versioned_decode_from_slice}, prelude::{DataContract, Identity}, serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, PlatformSerializableWithPlatformVersion, }, voting::votes::{resource_vote::ResourceVote, Vote}, @@ -191,7 +191,8 @@ impl MockResponse for DataContract { where Self: Sized, { - DataContract::versioned_deserialize(buf, true, sdk.version()).expect("decode data") + DataContract::versioned_deserialize_untrusted(buf, true, sdk.version()) + .expect("decode data") } } @@ -207,7 +208,8 @@ impl MockResponse for (DataContract, Vec) { Self: Sized, { ( - DataContract::versioned_deserialize(buf, true, sdk.version()).expect("decode data"), + DataContract::versioned_deserialize_untrusted(buf, true, sdk.version()) + .expect("decode data"), buf.to_vec(), ) } diff --git a/packages/rs-sdk/src/platform/address_sync/mod.rs b/packages/rs-sdk/src/platform/address_sync/mod.rs index faac4648773..e8a323ffc4b 100644 --- a/packages/rs-sdk/src/platform/address_sync/mod.rs +++ b/packages/rs-sdk/src/platform/address_sync/mod.rs @@ -1181,7 +1181,7 @@ fn get_last_recent_block_from_proof(proof: &Proof) -> Result, Error> .with_limit::<{ 256 * 1024 * 1024 }>(); let (grovedb_proof, _): (drive::grovedb::operations::proof::GroveDBProof, usize) = - dpp::bincode::decode_from_slice(&proof.grovedb_proof, config).map_err(|e| { + dpp::bincode::decode_from_slice_untrusted(&proof.grovedb_proof, config).map_err(|e| { Error::Protocol(dpp::ProtocolError::DecodingError(format!( "Failed to decode GroveDB proof: {}", e diff --git a/packages/rs-sdk/src/sdk.rs b/packages/rs-sdk/src/sdk.rs index 43d833e7cad..c37e0ffb326 100644 --- a/packages/rs-sdk/src/sdk.rs +++ b/packages/rs-sdk/src/sdk.rs @@ -1307,7 +1307,7 @@ pub fn prettify_proof(proof: &Proof) -> String { .with_big_endian() .with_no_limit(); let grovedb_proof: Result = - bincode::decode_from_slice(&proof.grovedb_proof, config).map(|(a, _)| a); + bincode::decode_from_slice_untrusted(&proof.grovedb_proof, config).map(|(a, _)| a); let grovedb_proof_string = match grovedb_proof { Ok(proof) => format!("{}", proof), diff --git a/packages/strategy-tests/src/lib.rs b/packages/strategy-tests/src/lib.rs index 3cad9b40e80..f57ed69981f 100644 --- a/packages/strategy-tests/src/lib.rs +++ b/packages/strategy-tests/src/lib.rs @@ -96,7 +96,7 @@ use dpp::identity::{Identity, KeyID, KeyType, PartialIdentity, Purpose, Security use dpp::platform_value::string_encoding::Encoding; use dpp::platform_value::{BinaryData, Bytes32, Value}; use dpp::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted, PlatformSerializableWithPlatformVersion, }; use dpp::state_transition::address_credit_withdrawal_transition::methods::AddressCreditWithdrawalTransitionMethodsV0; @@ -436,8 +436,8 @@ impl PlatformSerializableWithPlatformVersion for Strategy { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Strategy { - fn versioned_deserialize( +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted for Strategy { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -468,7 +468,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Str let contracts_with_updates = contracts_with_updates .into_iter() .map(|(serialized_contract, maybe_updates)| { - let contract = CreatedDataContract::versioned_deserialize( + let contract = CreatedDataContract::versioned_deserialize_trusted( serialized_contract.as_slice(), full_validation, platform_version, @@ -478,7 +478,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Str updates .into_iter() .map(|(key, serialized_contract_update)| { - let update = CreatedDataContract::versioned_deserialize( + let update = CreatedDataContract::versioned_deserialize_trusted( serialized_contract_update.as_slice(), full_validation, platform_version, @@ -501,7 +501,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Str let operations = operations .into_iter() .map(|operation| { - Operation::versioned_deserialize( + Operation::versioned_deserialize_trusted( operation.as_slice(), full_validation, platform_version, @@ -3026,7 +3026,7 @@ mod tests { use dpp::identity::Identity; use dpp::platform_value::Value; use dpp::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted, PlatformSerializableWithPlatformVersion, }; use dpp::system_data_contracts::load_system_data_contract; @@ -3156,7 +3156,7 @@ mod tests { .expect("expected to serialize"); let deserialized = - Strategy::versioned_deserialize(serialized.as_slice(), true, platform_version) + Strategy::versioned_deserialize_trusted(serialized.as_slice(), true, platform_version) .expect("expected to deserialize"); assert_eq!(strategy, deserialized); diff --git a/packages/strategy-tests/src/operations.rs b/packages/strategy-tests/src/operations.rs index b4b89bfd872..0b6d47e5658 100644 --- a/packages/strategy-tests/src/operations.rs +++ b/packages/strategy-tests/src/operations.rs @@ -48,7 +48,7 @@ use dpp::identifier::Identifier; use dpp::identity::{IdentityPublicKey, KeyCount}; use dpp::platform_value::Value; use dpp::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted, PlatformSerializableWithPlatformVersion, }; use dpp::tokens::token_event::TokenEvent; @@ -137,8 +137,8 @@ impl PlatformSerializableWithPlatformVersion for TokenOp { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for TokenOp { - fn versioned_deserialize( +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted for TokenOp { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -272,8 +272,8 @@ impl PlatformSerializableWithPlatformVersion for DocumentOp { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for DocumentOp { - fn versioned_deserialize( +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted for DocumentOp { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -369,8 +369,8 @@ impl PlatformSerializableWithPlatformVersion for Operation { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Operation { - fn versioned_deserialize( +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted for Operation { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -389,7 +389,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Ope .0; let OperationInSerializationFormat { op_type, frequency } = operation_in_serialization_format; - let op_type = OperationType::versioned_deserialize( + let op_type = OperationType::versioned_deserialize_trusted( op_type.as_slice(), full_validation, platform_version, @@ -494,8 +494,10 @@ impl PlatformSerializableWithPlatformVersion for DataContractUpdateOp { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for DataContractUpdateOp { - fn versioned_deserialize( +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted + for DataContractUpdateOp +{ + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -1007,8 +1009,8 @@ impl PlatformSerializableWithPlatformVersion for OperationType { } } -impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for OperationType { - fn versioned_deserialize( +impl PlatformDeserializableWithPotentialValidationFromVersionedStructureTrusted for OperationType { + fn versioned_deserialize_trusted( data: &[u8], full_validation: bool, platform_version: &PlatformVersion, @@ -1027,7 +1029,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Ope .0; Ok(match operation_type { OperationTypeInSerializationFormat::Document(serialized_op) => { - let document_op = DocumentOp::versioned_deserialize( + let document_op = DocumentOp::versioned_deserialize_trusted( serialized_op.as_slice(), full_validation, platform_version, @@ -1050,7 +1052,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Ope OperationType::ContractCreate(p, c) } OperationTypeInSerializationFormat::ContractUpdate(serialized_op) => { - let update_op = DataContractUpdateOp::versioned_deserialize( + let update_op = DataContractUpdateOp::versioned_deserialize_trusted( serialized_op.as_slice(), full_validation, platform_version, @@ -1065,7 +1067,7 @@ impl PlatformDeserializableWithPotentialValidationFromVersionedStructure for Ope OperationType::ResourceVote(vote_op) } OperationTypeInSerializationFormat::Token(serialized_token_op) => { - let token_op = TokenOp::versioned_deserialize( + let token_op = TokenOp::versioned_deserialize_trusted( serialized_token_op.as_slice(), full_validation, platform_version, diff --git a/packages/wasm-dpp/src/data_contract/state_transition/data_contract_create_transition/mod.rs b/packages/wasm-dpp/src/data_contract/state_transition/data_contract_create_transition/mod.rs index 197f652ac31..cadd0089477 100644 --- a/packages/wasm-dpp/src/data_contract/state_transition/data_contract_create_transition/mod.rs +++ b/packages/wasm-dpp/src/data_contract/state_transition/data_contract_create_transition/mod.rs @@ -7,7 +7,7 @@ use crate::errors::protocol_error::from_protocol_error; use dpp::errors::consensus::signature::SignatureError; use dpp::errors::consensus::ConsensusError; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0; use dpp::state_transition::data_contract_create_transition::DataContractCreateTransition; use dpp::state_transition::StateTransitionHasUserFeeIncrease; @@ -169,7 +169,8 @@ impl DataContractCreateTransitionWasm { #[wasm_bindgen(js_name=fromBuffer)] pub fn from_buffer(buffer: Vec) -> Result { let state_transition: StateTransition = - PlatformDeserializable::deserialize_from_bytes(&buffer).with_js_error()?; + PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(&buffer) + .with_js_error()?; match state_transition { StateTransition::DataContractCreate(dct) => Ok(dct.into()), _ => Err(JsValue::from_str("Invalid state transition type")), diff --git a/packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/mod.rs b/packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/mod.rs index dfcddef8c94..a5da725fe1a 100644 --- a/packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/mod.rs +++ b/packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/mod.rs @@ -4,7 +4,7 @@ use dpp::consensus::ConsensusError; use dpp::serialization::ValueConvertible; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0; use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition; use dpp::state_transition::StateTransition; @@ -164,7 +164,8 @@ impl DataContractUpdateTransitionWasm { #[wasm_bindgen(js_name=fromBuffer)] pub fn from_buffer(buffer: Vec) -> Result { let state_transition: StateTransition = - PlatformDeserializable::deserialize_from_bytes(&buffer).with_js_error()?; + PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(&buffer) + .with_js_error()?; match state_transition { StateTransition::DataContractUpdate(dct) => Ok(dct.into()), _ => Err(JsValue::from_str("Invalid state transition type")), diff --git a/packages/wasm-dpp/src/errors/consensus/deserialize.rs b/packages/wasm-dpp/src/errors/consensus/deserialize.rs index 94503dd884e..51b25600bb1 100644 --- a/packages/wasm-dpp/src/errors/consensus/deserialize.rs +++ b/packages/wasm-dpp/src/errors/consensus/deserialize.rs @@ -1,12 +1,12 @@ use crate::errors::consensus::consensus_error::from_consensus_error; use dpp::consensus::ConsensusError; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use wasm_bindgen::prelude::wasm_bindgen; use wasm_bindgen::{JsError, JsValue}; #[wasm_bindgen(js_name=deserializeConsensusError)] pub fn deserialize_consensus_error(bytes: Vec) -> Result { - ConsensusError::deserialize_from_bytes(bytes.as_slice()) + ConsensusError::deserialize_from_bytes_untrusted(bytes.as_slice()) .map(from_consensus_error) .map_err(|e| e.into()) } diff --git a/packages/wasm-dpp/src/identity/identity.rs b/packages/wasm-dpp/src/identity/identity.rs index 1db256f0f00..79de7595a22 100644 --- a/packages/wasm-dpp/src/identity/identity.rs +++ b/packages/wasm-dpp/src/identity/identity.rs @@ -10,7 +10,7 @@ use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV use dpp::identity::{Identity, IdentityPublicKey, KeyID}; use dpp::metadata::Metadata; use dpp::platform_value::ReplacementType; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use dpp::serialization::PlatformSerializable; use dpp::serialization::ValueConvertible; use dpp::version::PlatformVersion; @@ -267,7 +267,8 @@ impl IdentityWasm { #[wasm_bindgen(js_name=fromBuffer)] pub fn from_buffer(buffer: Vec) -> Result { let identity: Identity = - PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?; + PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(buffer.as_slice()) + .with_js_error()?; Ok(identity.into()) } } diff --git a/packages/wasm-dpp/src/identity/identity_public_key/mod.rs b/packages/wasm-dpp/src/identity/identity_public_key/mod.rs index cf91b4e404c..580f7e16059 100644 --- a/packages/wasm-dpp/src/identity/identity_public_key/mod.rs +++ b/packages/wasm-dpp/src/identity/identity_public_key/mod.rs @@ -11,7 +11,7 @@ use dpp::identity::identity_public_key::accessors::v0::{ use dpp::identity::identity_public_key::hash::IdentityPublicKeyHashMethodsV0; use dpp::identity::{IdentityPublicKey, KeyID, TimestampMillis}; use dpp::platform_value::{BinaryData, ReplacementType}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable, ValueConvertible}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, ValueConvertible}; use dpp::ProtocolError; use dpp::version::PlatformVersion; @@ -196,7 +196,8 @@ impl IdentityPublicKeyWasm { #[wasm_bindgen(js_name=fromBuffer)] pub fn from_buffer(buffer: Vec) -> Result { let key: IdentityPublicKey = - PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?; + PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(buffer.as_slice()) + .with_js_error()?; Ok(key.into()) } } diff --git a/packages/wasm-dpp/src/identity/mod.rs b/packages/wasm-dpp/src/identity/mod.rs index 141b152b936..2862a015658 100644 --- a/packages/wasm-dpp/src/identity/mod.rs +++ b/packages/wasm-dpp/src/identity/mod.rs @@ -12,7 +12,7 @@ mod identity_public_key; // use dpp::identity::IdentityPublicKey; // use dpp::identity::{Identity, KeyID}; // use dpp::metadata::Metadata; -// use dpp::serialization::serialization_traits::{PlatformDeserializable, PlatformSerializable}; +// use dpp::serialization::serialization_traits::{PlatformDeserializableUntrusted, PlatformSerializable}; // use dpp::{ ProtocolError}; // // use crate::identifier::IdentifierWrapper; diff --git a/packages/wasm-dpp/src/utils.rs b/packages/wasm-dpp/src/utils.rs index 665f8fbc70f..9096f5d34ff 100644 --- a/packages/wasm-dpp/src/utils.rs +++ b/packages/wasm-dpp/src/utils.rs @@ -5,7 +5,7 @@ use anyhow::{anyhow, bail, Context}; use dpp::{consensus::ConsensusError, ProtocolError}; use dpp::platform_value::Value; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use js_sys::{Function, Uint8Array}; use serde::de::DeserializeOwned; use serde_json::Value as JsonValue; @@ -355,7 +355,7 @@ pub(crate) fn consensus_errors_from_buffers( .to_vec() }) .map(|error_bytes| { - ConsensusError::deserialize_from_bytes(&error_bytes.to_vec()).with_js_error() + ConsensusError::deserialize_from_bytes_untrusted(&error_bytes.to_vec()).with_js_error() }) .collect::, JsValue>>() } diff --git a/packages/wasm-dpp2/src/asset_lock_proof/chain.rs b/packages/wasm-dpp2/src/asset_lock_proof/chain.rs index d320c99c5ec..ff0a8d7b113 100644 --- a/packages/wasm-dpp2/src/asset_lock_proof/chain.rs +++ b/packages/wasm-dpp2/src/asset_lock_proof/chain.rs @@ -3,7 +3,7 @@ use crate::error::{WasmDppError, WasmDppResult}; use crate::identifier::IdentifierWasm; use crate::impl_wasm_conversions_inner; use crate::impl_wasm_type_info; -use bincode::serde::{decode_from_slice, encode_to_vec}; +use bincode::serde::{decode_from_slice_untrusted, encode_to_vec}; use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof; use serde::{Deserialize, Serialize}; use wasm_bindgen::prelude::wasm_bindgen; @@ -104,9 +104,10 @@ impl ChainAssetLockProofWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let proof: ChainAssetLockProof = decode_from_slice(&bytes, bincode::config::standard()) - .map_err(|e| WasmDppError::serialization(e.to_string()))? - .0; + let proof: ChainAssetLockProof = + decode_from_slice_untrusted(&bytes, bincode::config::standard()) + .map_err(|e| WasmDppError::serialization(e.to_string()))? + .0; Ok(ChainAssetLockProofWasm(proof)) } } diff --git a/packages/wasm-dpp2/src/asset_lock_proof/proof.rs b/packages/wasm-dpp2/src/asset_lock_proof/proof.rs index 2b735d48b87..e752e778c63 100644 --- a/packages/wasm-dpp2/src/asset_lock_proof/proof.rs +++ b/packages/wasm-dpp2/src/asset_lock_proof/proof.rs @@ -211,9 +211,10 @@ impl AssetLockProofWasm { ) -> WasmDppResult { let bytes = hex::decode(asset_lock_proof) .map_err(|e| WasmDppError::serialization(e.to_string()))?; - let proof: AssetLockProof = bincode::decode_from_slice(&bytes, bincode::config::standard()) - .map_err(|e| WasmDppError::serialization(e.to_string()))? - .0; + let proof: AssetLockProof = + bincode::decode_from_slice_untrusted(&bytes, bincode::config::standard()) + .map_err(|e| WasmDppError::serialization(e.to_string()))? + .0; Ok(AssetLockProofWasm(proof)) } @@ -225,9 +226,10 @@ impl AssetLockProofWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let proof: AssetLockProof = bincode::decode_from_slice(&bytes, bincode::config::standard()) - .map_err(|e| WasmDppError::serialization(e.to_string()))? - .0; + let proof: AssetLockProof = + bincode::decode_from_slice_untrusted(&bytes, bincode::config::standard()) + .map_err(|e| WasmDppError::serialization(e.to_string()))? + .0; Ok(AssetLockProofWasm(proof)) } } diff --git a/packages/wasm-dpp2/src/consensus_error.rs b/packages/wasm-dpp2/src/consensus_error.rs index e3aa7cfa86c..bf88b894bc4 100644 --- a/packages/wasm-dpp2/src/consensus_error.rs +++ b/packages/wasm-dpp2/src/consensus_error.rs @@ -2,7 +2,7 @@ use crate::error::WasmDppResult; use crate::impl_wasm_type_info; use dpp::consensus::ConsensusError; use dpp::consensus::codes::ErrorWithCode; -use dpp::serialization::PlatformDeserializable; +use dpp::serialization::PlatformDeserializableUntrusted; use wasm_bindgen::prelude::wasm_bindgen; /// Consensus error codes emitted by `refersTo` reference validation, which @@ -69,9 +69,9 @@ pub struct ConsensusErrorWasm(ConsensusError); impl ConsensusErrorWasm { #[wasm_bindgen(js_name = "deserialize")] pub fn deserialize(error: Vec) -> WasmDppResult { - Ok(ConsensusErrorWasm(ConsensusError::deserialize_from_bytes( - error.as_slice(), - )?)) + Ok(ConsensusErrorWasm( + ConsensusError::deserialize_from_bytes_untrusted(error.as_slice())?, + )) } #[wasm_bindgen(getter = "message")] diff --git a/packages/wasm-dpp2/src/data_contract/model.rs b/packages/wasm-dpp2/src/data_contract/model.rs index d421e6c33c9..a57b211b082 100644 --- a/packages/wasm-dpp2/src/data_contract/model.rs +++ b/packages/wasm-dpp2/src/data_contract/model.rs @@ -32,7 +32,7 @@ use dpp::platform_value::string_encoding::{decode, encode}; use dpp::platform_value::{Value, ValueMap}; use dpp::prelude::{Identifier, IdentityNonce}; use dpp::serialization::{ - PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, PlatformSerializableWithPlatformVersion, }; use dpp::version::{PlatformVersion, TryIntoPlatformVersioned}; @@ -680,7 +680,7 @@ impl DataContractWasm { ) -> WasmDppResult { let platform_version = PlatformVersionWasm::try_from(platform_version)?; - let rs_data_contract = DataContract::versioned_deserialize( + let rs_data_contract = DataContract::versioned_deserialize_untrusted( bytes.as_slice(), full_validation, &platform_version.into(), diff --git a/packages/wasm-dpp2/src/data_contract/transitions/create.rs b/packages/wasm-dpp2/src/data_contract/transitions/create.rs index 724cc77e3bf..4bf1cbd852f 100644 --- a/packages/wasm-dpp2/src/data_contract/transitions/create.rs +++ b/packages/wasm-dpp2/src/data_contract/transitions/create.rs @@ -8,7 +8,7 @@ use dpp::data_contract::serialized_version::DataContractInSerializationFormat; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::{DataContract, IdentityNonce}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::data_contract_create_transition::accessors::DataContractCreateTransitionAccessorsV0; use dpp::state_transition::data_contract_create_transition::{ @@ -92,7 +92,7 @@ impl DataContractCreateTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_data_contract_create_transition: DataContractCreateTransition = - DataContractCreateTransition::deserialize_from_bytes(bytes.as_slice())?; + DataContractCreateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(DataContractCreateTransitionWasm( rs_data_contract_create_transition, diff --git a/packages/wasm-dpp2/src/data_contract/transitions/update.rs b/packages/wasm-dpp2/src/data_contract/transitions/update.rs index 2a8e89b90b0..740746e38b2 100644 --- a/packages/wasm-dpp2/src/data_contract/transitions/update.rs +++ b/packages/wasm-dpp2/src/data_contract/transitions/update.rs @@ -8,7 +8,7 @@ use dpp::data_contract::serialized_version::DataContractInSerializationFormat; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::{DataContract, IdentityNonce}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::data_contract_update_transition::DataContractUpdateTransition; use dpp::state_transition::data_contract_update_transition::accessors::DataContractUpdateTransitionAccessorsV0; @@ -79,7 +79,7 @@ impl DataContractUpdateTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_data_contract_update_transition: DataContractUpdateTransition = - DataContractUpdateTransition::deserialize_from_bytes(bytes.as_slice())?; + DataContractUpdateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(DataContractUpdateTransitionWasm( rs_data_contract_update_transition, diff --git a/packages/wasm-dpp2/src/identity/model.rs b/packages/wasm-dpp2/src/identity/model.rs index fb9af6f6bf5..3f473a4f57c 100644 --- a/packages/wasm-dpp2/src/identity/model.rs +++ b/packages/wasm-dpp2/src/identity/model.rs @@ -13,7 +13,7 @@ use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::Identifier; use dpp::serialization::{ - JsonConvertible, PlatformDeserializable, PlatformSerializable, ValueConvertible, + JsonConvertible, PlatformDeserializableUntrusted, PlatformSerializable, ValueConvertible, }; use dpp::version::{PlatformVersion, TryFromPlatformVersioned}; use wasm_bindgen::prelude::wasm_bindgen; @@ -221,7 +221,7 @@ impl IdentityWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let identity = Identity::deserialize_from_bytes(bytes.as_slice())?; + let identity = Identity::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityWasm(identity)) } } diff --git a/packages/wasm-dpp2/src/identity/public_key.rs b/packages/wasm-dpp2/src/identity/public_key.rs index 264b1bdc73a..3ce788ab286 100644 --- a/packages/wasm-dpp2/src/identity/public_key.rs +++ b/packages/wasm-dpp2/src/identity/public_key.rs @@ -25,7 +25,7 @@ use dpp::identity::{IdentityPublicKey, KeyType, Purpose, SecurityLevel, Timestam use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use hex; use serde::Deserialize; use serde_json::Value as JsonValue; @@ -361,7 +361,7 @@ impl IdentityPublicKeyWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let public_key = IdentityPublicKey::deserialize_from_bytes(bytes.as_slice())?; + let public_key = IdentityPublicKey::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityPublicKeyWasm(public_key)) } @@ -371,7 +371,7 @@ impl IdentityPublicKeyWasm { let bytes = decode(&hex, Hex).map_err(|err| WasmDppError::serialization(err.to_string()))?; - let public_key = IdentityPublicKey::deserialize_from_bytes(bytes.as_slice())?; + let public_key = IdentityPublicKey::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityPublicKeyWasm(public_key)) } @@ -381,7 +381,7 @@ impl IdentityPublicKeyWasm { let bytes = decode(&hex, Base64).map_err(|err| WasmDppError::serialization(err.to_string()))?; - let public_key = IdentityPublicKey::deserialize_from_bytes(bytes.as_slice())?; + let public_key = IdentityPublicKey::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityPublicKeyWasm(public_key)) } diff --git a/packages/wasm-dpp2/src/identity/transitions/create_transition.rs b/packages/wasm-dpp2/src/identity/transitions/create_transition.rs index dbdd231f4cf..324738320f8 100644 --- a/packages/wasm-dpp2/src/identity/transitions/create_transition.rs +++ b/packages/wasm-dpp2/src/identity/transitions/create_transition.rs @@ -12,7 +12,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_create_transition::IdentityCreateTransition; use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0; use dpp::state_transition::identity_create_transition::v0::IdentityCreateTransitionV0; @@ -155,7 +155,8 @@ impl IdentityCreateTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let rs_transition = IdentityCreateTransition::deserialize_from_bytes(bytes.as_slice())?; + let rs_transition = + IdentityCreateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityCreateTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/identity/transitions/credit_withdrawal_transition.rs b/packages/wasm-dpp2/src/identity/transitions/credit_withdrawal_transition.rs index 6ec19b2a9d5..c2ff99bd790 100644 --- a/packages/wasm-dpp2/src/identity/transitions/credit_withdrawal_transition.rs +++ b/packages/wasm-dpp2/src/identity/transitions/credit_withdrawal_transition.rs @@ -15,7 +15,7 @@ use dpp::identity::state_transition::OptionallyAssetLockProved; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::{IdentityNonce, UserFeeIncrease}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_credit_withdrawal_transition::IdentityCreditWithdrawalTransition; use dpp::state_transition::identity_credit_withdrawal_transition::accessors::IdentityCreditWithdrawalTransitionAccessorsV0; use dpp::state_transition::identity_credit_withdrawal_transition::v1::IdentityCreditWithdrawalTransitionV1; @@ -329,7 +329,7 @@ impl IdentityCreditWithdrawalTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_transition = - IdentityCreditWithdrawalTransition::deserialize_from_bytes(bytes.as_slice())?; + IdentityCreditWithdrawalTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityCreditWithdrawalTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/identity/transitions/identity_credit_transfer_transition.rs b/packages/wasm-dpp2/src/identity/transitions/identity_credit_transfer_transition.rs index 3919bdef456..28f8f55dab8 100644 --- a/packages/wasm-dpp2/src/identity/transitions/identity_credit_transfer_transition.rs +++ b/packages/wasm-dpp2/src/identity/transitions/identity_credit_transfer_transition.rs @@ -8,7 +8,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_credit_transfer_transition::IdentityCreditTransferTransition; use dpp::state_transition::identity_credit_transfer_transition::accessors::IdentityCreditTransferTransitionAccessorsV0; use dpp::state_transition::identity_credit_transfer_transition::v0::IdentityCreditTransferTransitionV0; @@ -143,7 +143,7 @@ impl IdentityCreditTransferWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_transition = - IdentityCreditTransferTransition::deserialize_from_bytes(bytes.as_slice())?; + IdentityCreditTransferTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityCreditTransferWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/identity/transitions/masternode_vote_transition.rs b/packages/wasm-dpp2/src/identity/transitions/masternode_vote_transition.rs index a703460a7e3..19eba3bd04b 100644 --- a/packages/wasm-dpp2/src/identity/transitions/masternode_vote_transition.rs +++ b/packages/wasm-dpp2/src/identity/transitions/masternode_vote_transition.rs @@ -12,7 +12,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::IdentityNonce; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::masternode_vote_transition::MasternodeVoteTransition; use dpp::state_transition::masternode_vote_transition::accessors::MasternodeVoteTransitionAccessorsV0; use dpp::state_transition::masternode_vote_transition::v0::MasternodeVoteTransitionV0; @@ -235,7 +235,8 @@ impl MasternodeVoteTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let rs_transition = MasternodeVoteTransition::deserialize_from_bytes(bytes.as_slice())?; + let rs_transition = + MasternodeVoteTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(MasternodeVoteTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/identity/transitions/top_up_transition.rs b/packages/wasm-dpp2/src/identity/transitions/top_up_transition.rs index bf8c83d32d0..69d289e9bff 100644 --- a/packages/wasm-dpp2/src/identity/transitions/top_up_transition.rs +++ b/packages/wasm-dpp2/src/identity/transitions/top_up_transition.rs @@ -9,7 +9,7 @@ use dpp::identity::state_transition::{AssetLockProved, OptionallyAssetLockProved use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition; use dpp::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0; use dpp::state_transition::identity_topup_transition::v0::IdentityTopUpTransitionV0; @@ -200,7 +200,8 @@ impl IdentityTopUpTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let rs_transition = IdentityTopUpTransition::deserialize_from_bytes(bytes.as_slice())?; + let rs_transition = + IdentityTopUpTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityTopUpTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/identity/transitions/update_transition.rs b/packages/wasm-dpp2/src/identity/transitions/update_transition.rs index 5e78fd186e9..94ed992a23c 100644 --- a/packages/wasm-dpp2/src/identity/transitions/update_transition.rs +++ b/packages/wasm-dpp2/src/identity/transitions/update_transition.rs @@ -12,7 +12,7 @@ use dpp::identity::state_transition::OptionallyAssetLockProved; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::{IdentityNonce, Revision, UserFeeIncrease}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_update_transition::IdentityUpdateTransition; use dpp::state_transition::identity_update_transition::accessors::IdentityUpdateTransitionAccessorsV0; use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0; @@ -320,7 +320,8 @@ impl IdentityUpdateTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let rs_transition = IdentityUpdateTransition::deserialize_from_bytes(bytes.as_slice())?; + let rs_transition = + IdentityUpdateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(IdentityUpdateTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/platform_address/transitions/address_credit_withdrawal_transition.rs b/packages/wasm-dpp2/src/platform_address/transitions/address_credit_withdrawal_transition.rs index a43b86f8bdd..c1344dd9cd5 100644 --- a/packages/wasm-dpp2/src/platform_address/transitions/address_credit_withdrawal_transition.rs +++ b/packages/wasm-dpp2/src/platform_address/transitions/address_credit_withdrawal_transition.rs @@ -15,7 +15,7 @@ use crate::utils::{ use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::address_credit_withdrawal_transition::AddressCreditWithdrawalTransition; use dpp::state_transition::address_credit_withdrawal_transition::v0::AddressCreditWithdrawalTransitionV0; @@ -136,7 +136,7 @@ impl AddressCreditWithdrawalTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_transition = - AddressCreditWithdrawalTransition::deserialize_from_bytes(bytes.as_slice())?; + AddressCreditWithdrawalTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(AddressCreditWithdrawalTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/platform_address/transitions/address_funding_from_asset_lock_transition.rs b/packages/wasm-dpp2/src/platform_address/transitions/address_funding_from_asset_lock_transition.rs index aa4388276da..99d4f7cd643 100644 --- a/packages/wasm-dpp2/src/platform_address/transitions/address_funding_from_asset_lock_transition.rs +++ b/packages/wasm-dpp2/src/platform_address/transitions/address_funding_from_asset_lock_transition.rs @@ -11,7 +11,7 @@ use crate::utils::{try_from_options, try_from_options_optional_with, try_to_u16} use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::address_funding_from_asset_lock_transition::AddressFundingFromAssetLockTransition; use dpp::state_transition::address_funding_from_asset_lock_transition::accessors::AddressFundingFromAssetLockTransitionAccessorsV0; @@ -121,7 +121,9 @@ impl AddressFundingFromAssetLockTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_transition = - AddressFundingFromAssetLockTransition::deserialize_from_bytes(bytes.as_slice())?; + AddressFundingFromAssetLockTransition::deserialize_from_bytes_untrusted( + bytes.as_slice(), + )?; Ok(AddressFundingFromAssetLockTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/platform_address/transitions/address_funds_transfer_transition.rs b/packages/wasm-dpp2/src/platform_address/transitions/address_funds_transfer_transition.rs index e46d65078ff..2ba3a1d5c5f 100644 --- a/packages/wasm-dpp2/src/platform_address/transitions/address_funds_transfer_transition.rs +++ b/packages/wasm-dpp2/src/platform_address/transitions/address_funds_transfer_transition.rs @@ -11,7 +11,7 @@ use crate::utils::{try_from_options_optional_with, try_to_u16}; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::address_funds_transfer_transition::AddressFundsTransferTransition; use dpp::state_transition::address_funds_transfer_transition::v0::AddressFundsTransferTransitionV0; @@ -114,7 +114,7 @@ impl AddressFundsTransferTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_transition = - AddressFundsTransferTransition::deserialize_from_bytes(bytes.as_slice())?; + AddressFundsTransferTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(AddressFundsTransferTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/platform_address/transitions/identity_create_from_addresses_transition.rs b/packages/wasm-dpp2/src/platform_address/transitions/identity_create_from_addresses_transition.rs index 42b47e95a80..ff1bad6bbaf 100644 --- a/packages/wasm-dpp2/src/platform_address/transitions/identity_create_from_addresses_transition.rs +++ b/packages/wasm-dpp2/src/platform_address/transitions/identity_create_from_addresses_transition.rs @@ -14,7 +14,7 @@ use crate::utils::{ use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::identity_create_from_addresses_transition::IdentityCreateFromAddressesTransition; use dpp::state_transition::identity_create_from_addresses_transition::v0::IdentityCreateFromAddressesTransitionV0; @@ -127,7 +127,9 @@ impl IdentityCreateFromAddressesTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { let rs_transition = - IdentityCreateFromAddressesTransition::deserialize_from_bytes(bytes.as_slice())?; + IdentityCreateFromAddressesTransition::deserialize_from_bytes_untrusted( + bytes.as_slice(), + )?; Ok(IdentityCreateFromAddressesTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/platform_address/transitions/identity_credit_transfer_to_addresses_transition.rs b/packages/wasm-dpp2/src/platform_address/transitions/identity_credit_transfer_to_addresses_transition.rs index bc093c73cd7..528814a46d6 100644 --- a/packages/wasm-dpp2/src/platform_address/transitions/identity_credit_transfer_to_addresses_transition.rs +++ b/packages/wasm-dpp2/src/platform_address/transitions/identity_credit_transfer_to_addresses_transition.rs @@ -11,7 +11,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_credit_transfer_to_addresses_transition::IdentityCreditTransferToAddressesTransition; use dpp::state_transition::identity_credit_transfer_to_addresses_transition::accessors::IdentityCreditTransferToAddressesTransitionAccessorsV0; use dpp::state_transition::identity_credit_transfer_to_addresses_transition::v0::IdentityCreditTransferToAddressesTransitionV0; @@ -133,7 +133,9 @@ impl IdentityCreditTransferToAddressesTransitionWasm { bytes: Vec, ) -> WasmDppResult { let rs_transition = - IdentityCreditTransferToAddressesTransition::deserialize_from_bytes(bytes.as_slice())?; + IdentityCreditTransferToAddressesTransition::deserialize_from_bytes_untrusted( + bytes.as_slice(), + )?; Ok(IdentityCreditTransferToAddressesTransitionWasm( rs_transition, diff --git a/packages/wasm-dpp2/src/platform_address/transitions/identity_top_up_from_addresses_transition.rs b/packages/wasm-dpp2/src/platform_address/transitions/identity_top_up_from_addresses_transition.rs index dc3a299a78b..06ce30278a8 100644 --- a/packages/wasm-dpp2/src/platform_address/transitions/identity_top_up_from_addresses_transition.rs +++ b/packages/wasm-dpp2/src/platform_address/transitions/identity_top_up_from_addresses_transition.rs @@ -11,7 +11,7 @@ use crate::utils::{try_from_options_optional, try_from_options_optional_with, tr use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::StateTransition; use dpp::state_transition::identity_topup_from_addresses_transition::IdentityTopUpFromAddressesTransition; use dpp::state_transition::identity_topup_from_addresses_transition::v0::IdentityTopUpFromAddressesTransitionV0; @@ -119,8 +119,9 @@ impl IdentityTopUpFromAddressesTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let rs_transition = - IdentityTopUpFromAddressesTransition::deserialize_from_bytes(bytes.as_slice())?; + let rs_transition = IdentityTopUpFromAddressesTransition::deserialize_from_bytes_untrusted( + bytes.as_slice(), + )?; Ok(IdentityTopUpFromAddressesTransitionWasm(rs_transition)) } diff --git a/packages/wasm-dpp2/src/shielded/identity_create_from_shielded_pool_transition.rs b/packages/wasm-dpp2/src/shielded/identity_create_from_shielded_pool_transition.rs index 2965d9cfb54..cc40687dd3f 100644 --- a/packages/wasm-dpp2/src/shielded/identity_create_from_shielded_pool_transition.rs +++ b/packages/wasm-dpp2/src/shielded/identity_create_from_shielded_pool_transition.rs @@ -6,7 +6,7 @@ use crate::shielded::orchard_action::{SerializedOrchardActionWasm, actions_from_ use crate::utils::try_vec_to_fixed_bytes; use crate::utils::{try_from_options, try_from_options_with, try_to_array}; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_create_from_shielded_pool_transition::IdentityCreateFromShieldedPoolTransition; use dpp::state_transition::identity_create_from_shielded_pool_transition::derive_identity_id_from_actions; use dpp::state_transition::identity_create_from_shielded_pool_transition::v0::IdentityCreateFromShieldedPoolTransitionV0; @@ -257,7 +257,7 @@ impl IdentityCreateFromShieldedPoolTransitionWasm { pub fn from_bytes( bytes: Vec, ) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::IdentityCreateFromShieldedPool(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/identity_top_up_from_shielded_pool_transition.rs b/packages/wasm-dpp2/src/shielded/identity_top_up_from_shielded_pool_transition.rs index acdc9c4b811..50d23f6b96c 100644 --- a/packages/wasm-dpp2/src/shielded/identity_top_up_from_shielded_pool_transition.rs +++ b/packages/wasm-dpp2/src/shielded/identity_top_up_from_shielded_pool_transition.rs @@ -6,7 +6,7 @@ use crate::utils::try_vec_to_fixed_bytes; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::identity_top_up_from_shielded_pool_transition::IdentityTopUpFromShieldedPoolTransition; use dpp::state_transition::identity_top_up_from_shielded_pool_transition::accessors::IdentityTopUpFromShieldedPoolTransitionAccessorsV0; use dpp::state_transition::identity_top_up_from_shielded_pool_transition::v0::IdentityTopUpFromShieldedPoolTransitionV0; @@ -193,7 +193,7 @@ impl IdentityTopUpFromShieldedPoolTransitionWasm { pub fn from_bytes( bytes: Vec, ) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::IdentityTopUpFromShieldedPool(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/shield_from_asset_lock_transition.rs b/packages/wasm-dpp2/src/shielded/shield_from_asset_lock_transition.rs index ac9441dca2f..93f971f89d7 100644 --- a/packages/wasm-dpp2/src/shielded/shield_from_asset_lock_transition.rs +++ b/packages/wasm-dpp2/src/shielded/shield_from_asset_lock_transition.rs @@ -6,7 +6,7 @@ use crate::shielded::orchard_action::{SerializedOrchardActionWasm, actions_from_ use crate::utils::{try_from_options, try_from_options_optional, try_vec_to_fixed_bytes}; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; use dpp::platform_value::BinaryData; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::shield_from_asset_lock_transition::ShieldFromAssetLockTransition; use dpp::state_transition::shield_from_asset_lock_transition::v0::ShieldFromAssetLockTransitionV0; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -241,7 +241,7 @@ impl ShieldFromAssetLockTransitionWasm { #[wasm_bindgen(js_name = fromBytes)] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::ShieldFromAssetLock(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/shield_from_identity_transition.rs b/packages/wasm-dpp2/src/shielded/shield_from_identity_transition.rs index 4ec39b1eef5..11763e2ac35 100644 --- a/packages/wasm-dpp2/src/shielded/shield_from_identity_transition.rs +++ b/packages/wasm-dpp2/src/shielded/shield_from_identity_transition.rs @@ -9,7 +9,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::shield_from_identity_transition::ShieldFromIdentityTransition; use dpp::state_transition::shield_from_identity_transition::accessors::ShieldFromIdentityTransitionAccessorsV0; use dpp::state_transition::shield_from_identity_transition::v0::ShieldFromIdentityTransitionV0; @@ -277,7 +277,7 @@ impl ShieldFromIdentityTransitionWasm { #[wasm_bindgen(js_name = fromBytes)] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::ShieldFromIdentity(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/shield_transition.rs b/packages/wasm-dpp2/src/shielded/shield_transition.rs index 1192488977f..e2c347e13ca 100644 --- a/packages/wasm-dpp2/src/shielded/shield_transition.rs +++ b/packages/wasm-dpp2/src/shielded/shield_transition.rs @@ -10,7 +10,7 @@ use crate::utils::try_vec_to_fixed_bytes; use crate::utils::{try_from_options_optional_with, try_to_u16}; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::shield_transition::ShieldTransition; use dpp::state_transition::shield_transition::v0::ShieldTransitionV0; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -265,7 +265,7 @@ impl ShieldTransitionWasm { #[wasm_bindgen(js_name = fromBytes)] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::Shield(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/shielded_transfer_transition.rs b/packages/wasm-dpp2/src/shielded/shielded_transfer_transition.rs index 184df9a3631..50a1eb53342 100644 --- a/packages/wasm-dpp2/src/shielded/shielded_transfer_transition.rs +++ b/packages/wasm-dpp2/src/shielded/shielded_transfer_transition.rs @@ -3,7 +3,7 @@ use crate::identifier::IdentifierWasm; use crate::shielded::orchard_action::{SerializedOrchardActionWasm, actions_from_js_options}; use crate::utils::try_vec_to_fixed_bytes; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::shielded_transfer_transition::ShieldedTransferTransition; use dpp::state_transition::shielded_transfer_transition::v0::ShieldedTransferTransitionV0; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -177,7 +177,7 @@ impl ShieldedTransferTransitionWasm { #[wasm_bindgen(js_name = fromBytes)] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::ShieldedTransfer(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/shielded_withdrawal_transition.rs b/packages/wasm-dpp2/src/shielded/shielded_withdrawal_transition.rs index 3877231c1ef..33acd15b0df 100644 --- a/packages/wasm-dpp2/src/shielded/shielded_withdrawal_transition.rs +++ b/packages/wasm-dpp2/src/shielded/shielded_withdrawal_transition.rs @@ -7,7 +7,7 @@ use crate::utils::try_from_options; use crate::utils::try_vec_to_fixed_bytes; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; use dpp::identity::core_script::CoreScript; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::shielded_withdrawal_transition::ShieldedWithdrawalTransition; use dpp::state_transition::shielded_withdrawal_transition::v0::ShieldedWithdrawalTransitionV0; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -227,7 +227,7 @@ impl ShieldedWithdrawalTransitionWasm { #[wasm_bindgen(js_name = fromBytes)] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::ShieldedWithdrawal(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/shielded/unshield_transition.rs b/packages/wasm-dpp2/src/shielded/unshield_transition.rs index 19e192d835e..e171f24c5ed 100644 --- a/packages/wasm-dpp2/src/shielded/unshield_transition.rs +++ b/packages/wasm-dpp2/src/shielded/unshield_transition.rs @@ -5,7 +5,7 @@ use crate::shielded::orchard_action::{SerializedOrchardActionWasm, actions_from_ use crate::utils::try_from_options; use crate::utils::try_vec_to_fixed_bytes; use crate::{impl_wasm_conversions_inner, impl_wasm_type_info}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::unshield_transition::UnshieldTransition; use dpp::state_transition::unshield_transition::v0::UnshieldTransitionV0; use dpp::state_transition::{StateTransition, StateTransitionLike}; @@ -194,7 +194,7 @@ impl UnshieldTransitionWasm { #[wasm_bindgen(js_name = fromBytes)] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(&bytes)?; + let st = StateTransition::deserialize_from_bytes_untrusted(&bytes)?; match st { StateTransition::Unshield(inner) => Ok(inner.into()), _ => Err(WasmDppError::invalid_argument( diff --git a/packages/wasm-dpp2/src/state_transitions/base/state_transition.rs b/packages/wasm-dpp2/src/state_transitions/base/state_transition.rs index d99ab4b6686..cce5e70e488 100644 --- a/packages/wasm-dpp2/src/state_transitions/base/state_transition.rs +++ b/packages/wasm-dpp2/src/state_transitions/base/state_transition.rs @@ -15,7 +15,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::{Encoding, decode, encode}; use dpp::prelude::Identifier; use dpp::prelude::{IdentityNonce, UserFeeIncrease}; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, Signable}; use dpp::state_transition::StateTransition::{ Batch, DataContractCreate, DataContractUpdate, IdentityCreditTransfer, IdentityCreditWithdrawal, IdentityUpdate, MasternodeVote, ShieldFromIdentity, @@ -252,7 +252,7 @@ impl StateTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let st = StateTransition::deserialize_from_bytes(bytes.as_slice())?; + let st = StateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(st.into()) } @@ -262,7 +262,7 @@ impl StateTransitionWasm { let bytes = decode(&hex, Encoding::Hex).map_err(|e| WasmDppError::serialization(e.to_string()))?; - let st = StateTransition::deserialize_from_bytes(bytes.as_slice())?; + let st = StateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(st.into()) } @@ -272,7 +272,7 @@ impl StateTransitionWasm { let bytes = decode(&base64, Encoding::Base64) .map_err(|e| WasmDppError::serialization(e.to_string()))?; - let st = StateTransition::deserialize_from_bytes(bytes.as_slice())?; + let st = StateTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(st.into()) } diff --git a/packages/wasm-dpp2/src/state_transitions/batch/batch_transition.rs b/packages/wasm-dpp2/src/state_transitions/batch/batch_transition.rs index e22ae5254dd..a1ee2efe8f2 100644 --- a/packages/wasm-dpp2/src/state_transitions/batch/batch_transition.rs +++ b/packages/wasm-dpp2/src/state_transitions/batch/batch_transition.rs @@ -10,7 +10,7 @@ use dpp::platform_value::BinaryData; use dpp::platform_value::string_encoding::Encoding::{Base64, Hex}; use dpp::platform_value::string_encoding::{decode, encode}; use dpp::prelude::UserFeeIncrease; -use dpp::serialization::{PlatformDeserializable, PlatformSerializable}; +use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable}; use dpp::state_transition::batch_transition::accessors::DocumentsBatchTransitionAccessorsV0; use dpp::state_transition::batch_transition::batched_transition::BatchedTransition; use dpp::state_transition::batch_transition::methods::v0::DocumentsBatchTransitionMethodsV0; @@ -226,7 +226,7 @@ impl BatchTransitionWasm { #[wasm_bindgen(js_name = "fromBytes")] pub fn from_bytes(bytes: Vec) -> WasmDppResult { - let rs_batch = BatchTransition::deserialize_from_bytes(bytes.as_slice())?; + let rs_batch = BatchTransition::deserialize_from_bytes_untrusted(bytes.as_slice())?; Ok(BatchTransitionWasm::from(rs_batch)) } diff --git a/packages/wasm-drive-verify/src/document/verify_proof.rs b/packages/wasm-drive-verify/src/document/verify_proof.rs index 8765d8c1f8b..bc84507158c 100644 --- a/packages/wasm-drive-verify/src/document/verify_proof.rs +++ b/packages/wasm-drive-verify/src/document/verify_proof.rs @@ -10,7 +10,7 @@ use crate::utils::serialization::document_to_js_value; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::DataContract; use dpp::platform_value::Value; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use drive::query::{DriveDocumentQuery, InternalClauses, OrderClause, WhereClause, WhereOperator}; use indexmap::IndexMap; use js_sys::{Array, Object, Reflect, Uint8Array}; @@ -72,8 +72,9 @@ pub fn verify_document_proof( )); }; - let contract = DataContract::versioned_deserialize(&contract_bytes, true, platform_version) - .map_err(|e| format_result_error(ErrorCategory::DeserializationError, e))?; + let contract = + DataContract::versioned_deserialize_untrusted(&contract_bytes, true, platform_version) + .map_err(|e| format_result_error(ErrorCategory::DeserializationError, e))?; // Get document type let document_type = contract diff --git a/packages/wasm-drive-verify/src/document/verify_proof_keep_serialized.rs b/packages/wasm-drive-verify/src/document/verify_proof_keep_serialized.rs index e2ec7aa2876..a0cff4d410c 100644 --- a/packages/wasm-drive-verify/src/document/verify_proof_keep_serialized.rs +++ b/packages/wasm-drive-verify/src/document/verify_proof_keep_serialized.rs @@ -3,7 +3,7 @@ use crate::utils::proof::supported_grovedb_proof; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::DataContract; use dpp::platform_value::Value; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dpp::version::PlatformVersion; use drive::query::{DriveDocumentQuery, InternalClauses, OrderClause, WhereClause, WhereOperator}; use indexmap::IndexMap; @@ -64,8 +64,9 @@ pub fn verify_document_proof_keep_serialized( )); }; - let contract = DataContract::versioned_deserialize(&contract_bytes, true, platform_version) - .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; + let contract = + DataContract::versioned_deserialize_untrusted(&contract_bytes, true, platform_version) + .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; // Get document type let document_type = contract diff --git a/packages/wasm-drive-verify/src/document/verify_start_at_document_in_proof.rs b/packages/wasm-drive-verify/src/document/verify_start_at_document_in_proof.rs index 4bb3791ac83..c06ceef7711 100644 --- a/packages/wasm-drive-verify/src/document/verify_start_at_document_in_proof.rs +++ b/packages/wasm-drive-verify/src/document/verify_start_at_document_in_proof.rs @@ -4,7 +4,7 @@ use crate::utils::serialization::document_to_js_value; use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::DataContract; use dpp::platform_value::Value; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dpp::version::PlatformVersion; use drive::query::{DriveDocumentQuery, InternalClauses, OrderClause, WhereClause, WhereOperator}; use indexmap::IndexMap; @@ -67,8 +67,9 @@ pub fn verify_start_at_document_in_proof( )); }; - let contract = DataContract::versioned_deserialize(&contract_bytes, true, platform_version) - .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; + let contract = + DataContract::versioned_deserialize_untrusted(&contract_bytes, true, platform_version) + .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; // Get document type let document_type = contract diff --git a/packages/wasm-drive-verify/src/voting/verify_identity_votes_given_proof.rs b/packages/wasm-drive-verify/src/voting/verify_identity_votes_given_proof.rs index d182064212a..6980bc2f3b7 100644 --- a/packages/wasm-drive-verify/src/voting/verify_identity_votes_given_proof.rs +++ b/packages/wasm-drive-verify/src/voting/verify_identity_votes_given_proof.rs @@ -3,7 +3,7 @@ use crate::utils::proof::supported_grovedb_proof; use crate::utils::serialization::identifier_to_base58; use dpp::data_contract::DataContract; use dpp::identifier::Identifier; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dpp::version::PlatformVersion; use dpp::voting::votes::resource_vote::ResourceVote; use drive::query::contested_resource_votes_given_by_identity_query::ContestedResourceVotesGivenByIdentityQuery; @@ -207,8 +207,11 @@ fn create_contract_lookup_fn<'a>( let contract_bytes = contract_uint8.to_vec(); // Deserialize the contract - let contract = DataContract::versioned_deserialize(&contract_bytes, true, platform_version) - .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; + let contract = + DataContract::versioned_deserialize_untrusted(&contract_bytes, true, platform_version) + .map_err(|e| { + JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)) + })?; use dpp::data_contract::accessors::v0::DataContractV0Getters; let identifier = contract.id(); diff --git a/packages/wasm-drive-verify/src/voting/verify_masternode_vote.rs b/packages/wasm-drive-verify/src/voting/verify_masternode_vote.rs index f1323559dae..e174f57d5ae 100644 --- a/packages/wasm-drive-verify/src/voting/verify_masternode_vote.rs +++ b/packages/wasm-drive-verify/src/voting/verify_masternode_vote.rs @@ -1,7 +1,7 @@ use crate::utils::getters::VecU8ToUint8Array; use crate::utils::proof::supported_grovedb_proof; use dpp::data_contract::DataContract; -use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructure; +use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted; use dpp::version::PlatformVersion; use dpp::voting::votes::Vote; use drive::drive::Drive; @@ -51,7 +51,7 @@ pub fn verify_masternode_vote( .map_err(|e| JsValue::from_str(&format!("Failed to deserialize vote: {:?}", e)))?; // Deserialize the data contract - let data_contract = DataContract::versioned_deserialize( + let data_contract = DataContract::versioned_deserialize_untrusted( &data_contract_cbor.to_vec(), true, platform_version, diff --git a/packages/wasm-drive-verify/src/voting/verify_vote_poll_vote_state_proof.rs b/packages/wasm-drive-verify/src/voting/verify_vote_poll_vote_state_proof.rs index 4455a001633..32d169ed05c 100644 --- a/packages/wasm-drive-verify/src/voting/verify_vote_poll_vote_state_proof.rs +++ b/packages/wasm-drive-verify/src/voting/verify_vote_poll_vote_state_proof.rs @@ -4,7 +4,8 @@ use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::DataContract; use dpp::identifier::Identifier; use dpp::serialization::{ - PlatformDeserializable, PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableUntrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, }; use dpp::version::PlatformVersion; use dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; @@ -55,14 +56,15 @@ pub fn verify_vote_poll_vote_state_proof( let platform_version = PlatformVersion::get(platform_version_number) .map_err(|e| JsValue::from_str(&format!("Invalid platform version: {:?}", e)))?; - let contract = DataContract::versioned_deserialize(&contract_bytes, true, platform_version) - .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; + let contract = + DataContract::versioned_deserialize_untrusted(&contract_bytes, true, platform_version) + .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; let contract_arc = Arc::new(contract); // A poll identifier alone cannot reconstruct its authenticated storage // path. Require the full poll and bind it to the independently supplied // contract and query context before proof verification. - let vote_poll = ContestedDocumentResourceVotePoll::deserialize_from_bytes( + let vote_poll = ContestedDocumentResourceVotePoll::deserialize_from_bytes_untrusted( &contested_document_resource_vote_poll_bytes.to_vec(), ) .map_err(|e| JsValue::from_str(&format!("Invalid vote poll: {:?}", e)))?; diff --git a/packages/wasm-drive-verify/src/voting/verify_vote_poll_votes_proof.rs b/packages/wasm-drive-verify/src/voting/verify_vote_poll_votes_proof.rs index 4e25b19727b..3a5e3ea8327 100644 --- a/packages/wasm-drive-verify/src/voting/verify_vote_poll_votes_proof.rs +++ b/packages/wasm-drive-verify/src/voting/verify_vote_poll_votes_proof.rs @@ -4,7 +4,8 @@ use dpp::data_contract::accessors::v0::DataContractV0Getters; use dpp::data_contract::DataContract; use dpp::identifier::Identifier; use dpp::serialization::{ - PlatformDeserializable, PlatformDeserializableWithPotentialValidationFromVersionedStructure, + PlatformDeserializableUntrusted, + PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted, }; use dpp::version::PlatformVersion; use dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll; @@ -55,15 +56,16 @@ pub fn verify_vote_poll_votes_proof( let platform_version = PlatformVersion::get(platform_version_number) .map_err(|e| JsValue::from_str(&format!("Invalid platform version: {:?}", e)))?; - let contract = DataContract::versioned_deserialize(&contract_bytes, true, platform_version) - .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; + let contract = + DataContract::versioned_deserialize_untrusted(&contract_bytes, true, platform_version) + .map_err(|e| JsValue::from_str(&format!("Failed to deserialize contract: {:?}", e)))?; let contract_arc = Arc::new(contract); // Parse the contestant ID let contestant_id_identifier = Identifier::from_bytes(&contestant_id.to_vec()) .map_err(|e| JsValue::from_str(&format!("Invalid contestant ID: {:?}", e)))?; - let vote_poll = ContestedDocumentResourceVotePoll::deserialize_from_bytes( + let vote_poll = ContestedDocumentResourceVotePoll::deserialize_from_bytes_untrusted( &contested_document_resource_vote_poll_bytes.to_vec(), ) .map_err(|e| JsValue::from_str(&format!("Invalid vote poll: {:?}", e)))?; diff --git a/packages/wasm-drive-verify/src/voting/verify_vote_polls_end_date_query.rs b/packages/wasm-drive-verify/src/voting/verify_vote_polls_end_date_query.rs index 71dfd2c1bfb..eede9d42e54 100644 --- a/packages/wasm-drive-verify/src/voting/verify_vote_polls_end_date_query.rs +++ b/packages/wasm-drive-verify/src/voting/verify_vote_polls_end_date_query.rs @@ -40,7 +40,7 @@ pub fn verify_vote_polls_end_date_query_vec( // Deserialize the query using bincode let query: VotePollsByEndDateDriveQuery = - bincode::decode_from_slice(&query_cbor.to_vec(), bincode::config::standard()) + bincode::decode_from_slice_untrusted(&query_cbor.to_vec(), bincode::config::standard()) .map_err(|e| JsValue::from_str(&format!("Failed to deserialize query: {:?}", e)))? .0; @@ -94,7 +94,7 @@ pub fn verify_vote_polls_end_date_query_map( // Deserialize the query using bincode let query: VotePollsByEndDateDriveQuery = - bincode::decode_from_slice(&query_cbor.to_vec(), bincode::config::standard()) + bincode::decode_from_slice_untrusted(&query_cbor.to_vec(), bincode::config::standard()) .map_err(|e| JsValue::from_str(&format!("Failed to deserialize query: {:?}", e)))? .0; diff --git a/packages/wasm-sdk/src/queries/identity.rs b/packages/wasm-sdk/src/queries/identity.rs index 9a3f3dfa1af..e52d3019818 100644 --- a/packages/wasm-sdk/src/queries/identity.rs +++ b/packages/wasm-sdk/src/queries/identity.rs @@ -431,14 +431,13 @@ impl WasmSdk { result: Some(get_identity_response_v0::Result::Identity(identity_bytes)), .. })) => { - use dash_sdk::dpp::serialization::PlatformDeserializable; - let identity = Identity::deserialize_from_bytes(identity_bytes.as_slice()) - .map_err(|e| { - WasmSdkError::serialization(format!( - "Failed to deserialize identity: {}", - e - )) - })?; + use dash_sdk::dpp::serialization::PlatformDeserializableUntrusted; + let identity = Identity::deserialize_from_bytes_untrusted( + identity_bytes.as_slice(), + ) + .map_err(|e| { + WasmSdkError::serialization(format!("Failed to deserialize identity: {}", e)) + })?; Ok(identity.into()) } _ => Err(WasmSdkError::not_found("Identity not found")),