From 05d016752da3e70f3b81151d5e862be755222e92 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Thu, 12 Nov 2026 17:41:59 +0700 Subject: [PATCH 1/5] feat(platform)!: dashpay contact requests carry an encrypted shielded address (PV15) DashPay v3 gives `contactRequest` one optional property, last in position: `encryptedShieldedAddress`, the sender's shielded payment address for this contact (43 bytes) under the same `encryptedFor` as `encryptedPublicKey`. That is 64 bytes, an IV and three AES blocks; the contract admits 64 to 80 and keeps 80 for a later encoding. A contact request stored under v1 or v2 ends before the property and reads back without it, which a test holds. Root and fee pins that depend on the stored DashPay contract are not moved yet. Co-Authored-By: Claude Fable 5.2 --- book/src/evo-sdk/dashpay-contact-requests.md | 14 +- .../schema/v3/dashpay.schema.json | 14 ++ packages/dashpay-contract/src/v3/mod.rs | 8 ++ packages/rs-dpp/src/system_data_contracts.rs | 120 +++++++++++++++++- .../rs-platform-version/src/version/v15.rs | 7 + 5 files changed, 157 insertions(+), 6 deletions(-) diff --git a/book/src/evo-sdk/dashpay-contact-requests.md b/book/src/evo-sdk/dashpay-contact-requests.md index 8add70f5f37..48381c9dcfb 100644 --- a/book/src/evo-sdk/dashpay-contact-requests.md +++ b/book/src/evo-sdk/dashpay-contact-requests.md @@ -48,6 +48,18 @@ recipient's identity decryption public key. ## What consensus checks +From protocol version 15 a contact request may also carry the optional +`encryptedShieldedAddress`: the sender's shielded payment address for this +contact, encrypted with the same shared secret. It is exactly 64 bytes: + +- 16 bytes: AES-CBC initialization vector, drawn at random for this field +- 48 bytes: AES-CBC ciphertext of the 43-byte address (an 11-byte diversifier + followed by a 32-byte transmission key) + +The contract accepts 64 to 80 bytes and keeps the 80-byte length for a later +encoding. A sender gives each contact a different address, so a payment that +arrives on one is attributed to that contact. + From protocol version 15 the DashPay contract (v3) states these checks in its schema, and a contact request that fails one is refused (and the fee charged): @@ -55,7 +67,7 @@ schema, and a contact request that fails one is refused (and the fee charged): | --- | --- | --- | | `toUserId` is not the sender | `distinctFrom: "$ownerId"` on `toUserId` | `DocumentPropertyNotDistinctError` (10419) | | The recipient identity exists | `refersTo` of type `identity` on `toUserId` | `ReferencedEntityNotFoundError` (40120) | -| `encryptedPublicKey` and `encryptedAccountLabel` are a 16-byte IV plus whole 16-byte blocks | `encryptedFor` with scheme `ecdh-secp256k1-aes256-cbc` | `InvalidEncryptedPropertyShapeError` (10420) | +| `encryptedPublicKey`, `encryptedAccountLabel` and `encryptedShieldedAddress` are a 16-byte IV plus whole 16-byte blocks | `encryptedFor` with scheme `ecdh-secp256k1-aes256-cbc` | `InvalidEncryptedPropertyShapeError` (10420) | Up to protocol version 14 a data trigger made only the first two checks and reported both as a `DataTriggerConditionError` (40500). Neither version checks diff --git a/packages/dashpay-contract/schema/v3/dashpay.schema.json b/packages/dashpay-contract/schema/v3/dashpay.schema.json index a7c3f794778..78baa19c3d7 100644 --- a/packages/dashpay-contract/schema/v3/dashpay.schema.json +++ b/packages/dashpay-contract/schema/v3/dashpay.schema.json @@ -285,6 +285,20 @@ "minItems": 38, "maxItems": 102, "position": 6 + }, + "encryptedShieldedAddress": { + "type": "array", + "byteArray": true, + "minItems": 64, + "maxItems": 80, + "encryptedFor": { + "recipient": "toUserId", + "recipientKey": "recipientKeyIndex", + "senderKey": "senderKeyIndex", + "scheme": "ecdh-secp256k1-aes256-cbc" + }, + "position": 7, + "description": "Sender's per-contact shielded payment address (43 bytes), encrypted to the contact with the DIP-15 shared key" } }, "required": [ diff --git a/packages/dashpay-contract/src/v3/mod.rs b/packages/dashpay-contract/src/v3/mod.rs index 3e6cdf5ea1b..6aaa59e2b09 100644 --- a/packages/dashpay-contract/src/v3/mod.rs +++ b/packages/dashpay-contract/src/v3/mod.rs @@ -19,6 +19,14 @@ use serde_json::Value; // check the profile data trigger made up to protocol version 14. Their descriptions say // so in place of v2's mention of the data trigger. // +// It adds one property: +// +// - `contactRequest.encryptedShieldedAddress`, optional and last in position: the +// sender's shielded payment address for this contact (43 bytes), encrypted as +// `encryptedPublicKey` is (`encryptedFor`). That is an IV and three AES blocks, +// 64 bytes; the 80-byte length is kept for a later encoding. A contact request +// stored before the property existed ends before it and reads back without it. +// // And it adds one type: // // - `privateContactRequest`, a private type of 589-byte entries: a contact request diff --git a/packages/rs-dpp/src/system_data_contracts.rs b/packages/rs-dpp/src/system_data_contracts.rs index 4c8ac1cf02e..4c26d2df695 100644 --- a/packages/rs-dpp/src/system_data_contracts.rs +++ b/packages/rs-dpp/src/system_data_contracts.rs @@ -1481,11 +1481,12 @@ mod dashpay_v3_tests { ConstraintExpression, PropertyConstraint, }; use crate::data_contract::document_type::{ - DistinctFrom, DocumentPropertyReferenceTarget, DocumentPropertyType, DocumentTypeRef, - EncryptedFor, EncryptedForRecipient, EncryptionScheme, + ByteArrayPropertySizes, DistinctFrom, DocumentPropertyReferenceTarget, + DocumentPropertyType, DocumentTypeRef, EncryptedFor, EncryptedForRecipient, + EncryptionScheme, }; use crate::document::serialization_traits::DocumentPlatformConversionMethodsV0; - use crate::document::DocumentV0; + use crate::document::{Document, DocumentV0, DocumentV0Getters}; use platform_value::{Identifier, Value}; use std::collections::BTreeMap; @@ -1625,7 +1626,7 @@ mod dashpay_v3_tests { } /// The two checks of the contact request data trigger, as declarations: the - /// recipient is an identity, and not the writer. The two ECDH fields name their + /// recipient is an identity, and not the writer. The three ECDH fields name their /// encryption, so their lengths must be an IV plus whole AES blocks. #[test] fn should_declare_the_contact_request_checks_and_encryption() { @@ -1660,11 +1661,120 @@ mod dashpay_v3_tests { encrypted, vec![ ("encryptedAccountLabel", recipe.clone()), - ("encryptedPublicKey", recipe), + ("encryptedPublicKey", recipe.clone()), + ("encryptedShieldedAddress", recipe), ] ); } + /// A contact request may carry the sender's shielded payment address for this + /// contact: 43 bytes encrypted as `encryptedPublicKey` is, so an IV and three AES + /// blocks (64 bytes), with the 80-byte length kept for a later encoding. The + /// property is optional and the last in position. + #[test] + fn should_let_a_contact_request_carry_an_encrypted_shielded_address() { + let contract = dashpay(); + let contact_request = document_type(&contract, "contactRequest"); + + let (last_name, last_property) = contact_request + .properties() + .last() + .expect("contactRequest has properties"); + assert_eq!(last_name, "encryptedShieldedAddress"); + assert!(!last_property.required); + assert_eq!( + last_property.property_type, + DocumentPropertyType::ByteArray(ByteArrayPropertySizes { + min_size: Some(64), + max_size: Some(80), + }) + ); + + // The private request carries the same address in the clear, inside its + // encrypted entry, so it has no encrypted form of it. + assert!(document_type(&contract, "privateContactRequest") + .flattened_properties() + .get("encryptedShieldedAddress") + .is_none()); + } + + /// A contact request stored under DashPay v2 ends before the property v3 adds. + /// Read under v3 it is the same document, without a shielded address. + #[test] + fn should_read_a_contact_request_stored_before_the_shielded_address_existed() { + let v3 = dashpay(); + let protocol_version_14 = PlatformVersion::get(14).expect("protocol version 14"); + let v2 = load_system_data_contract(SystemDataContract::Dashpay, protocol_version_14) + .expect("DashPay v2"); + assert!(document_type(&v2, "contactRequest") + .flattened_properties() + .get("encryptedShieldedAddress") + .is_none()); + + let stored_under_v2 = DocumentV0 { + id: Identifier::from([4; 32]), + owner_id: Identifier::from([5; 32]), + properties: BTreeMap::from([ + ("toUserId".to_string(), Value::Identifier([6; 32])), + ("encryptedPublicKey".to_string(), Value::Bytes(vec![7; 96])), + ("senderKeyIndex".to_string(), Value::I64(2)), + ("recipientKeyIndex".to_string(), Value::I64(3)), + ("accountReference".to_string(), Value::I64(0x0123_4567)), + ( + "encryptedAccountLabel".to_string(), + Value::Bytes(vec![8; 48]), + ), + ("autoAcceptProof".to_string(), Value::Bytes(vec![9; 38])), + ]), + created_at: Some(1_700_000_000_000), + created_at_core_block_height: Some(2_000_000), + ..Default::default() + }; + let bytes = stored_under_v2 + .serialize( + document_type(&v2, "contactRequest"), + &v2, + protocol_version_14, + ) + .expect("the contact request serializes under v2"); + + let read = Document::from_bytes( + &bytes, + document_type(&v3, "contactRequest"), + PlatformVersion::latest(), + ) + .expect("a v2 contact request reads under v3"); + assert_eq!(read.properties(), &stored_under_v2.properties); + assert_eq!(read.id(), stored_under_v2.id); + assert_eq!(read.owner_id(), stored_under_v2.owner_id); + assert_eq!(read.created_at(), stored_under_v2.created_at); + assert_eq!( + read.created_at_core_block_height(), + stored_under_v2.created_at_core_block_height + ); + + // With the address, the stored form grows by the property and nothing else moves. + let mut with_address = stored_under_v2.clone(); + with_address.properties.insert( + "encryptedShieldedAddress".to_string(), + Value::Bytes(vec![10; 64]), + ); + let bytes = with_address + .serialize( + document_type(&v3, "contactRequest"), + &v3, + PlatformVersion::latest(), + ) + .expect("the contact request serializes under v3"); + let read = Document::from_bytes( + &bytes, + document_type(&v3, "contactRequest"), + PlatformVersion::latest(), + ) + .expect("a v3 contact request reads back"); + assert_eq!(read.properties(), &with_address.properties); + } + /// The check of the profile data trigger, as two rules: each DIP-33 payment /// address starts with its type byte, 0x00 (P2PKH) or 0x01 (P2SH). A profile /// without the address reads its first byte as 0, so the rule holds, as the diff --git a/packages/rs-platform-version/src/version/v15.rs b/packages/rs-platform-version/src/version/v15.rs index e98239c2ab4..85c704885e1 100644 --- a/packages/rs-platform-version/src/version/v15.rs +++ b/packages/rs-platform-version/src/version/v15.rs @@ -554,6 +554,13 @@ pub const PROTOCOL_VERSION_15: ProtocolVersion = 15; /// profile create and replace triggers, which made the identity, writer and type byte /// checks and refused with `DataTriggerConditionError` (40500). Protocol v14 keeps /// DashPay v2 and bindings 2, and earlier versions the contract and bindings they had. +/// DashPay v3 also gives a `contactRequest` one property, the optional +/// `encryptedShieldedAddress`, last in position: the sender's shielded payment address +/// for this contact (43 bytes) under the same `encryptedFor` as `encryptedPublicKey`, +/// so 64 bytes, an IV and three AES blocks, with 80 kept for a later encoding (any +/// other length from 64 to 80 is `InvalidEncryptedPropertyShapeError`, 10420). A +/// contact request stored under v1 or v2 ends before the property and reads back +/// without it. /// DashPay v3 also declares `privateContactRequest`, a private type (note 13) of 589-byte /// entries whose properties describe a contact request only its recipient can read: /// `accountReference`, the DIP-15 compact `extendedPublicKey` (69 bytes), and the optional From 3fe572f43192b9c3ad96fa105e149eb4fa43259b Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Thu, 12 Nov 2026 18:21:23 +0700 Subject: [PATCH 2/5] test(platform): cover the contact request's shielded address and move its pins Three cases for `encryptedShieldedAddress` under DashPay v3: accepted at 64 and 80 bytes, refused at 70 (not an IV plus whole AES blocks, 10420), and refused before protocol version 15, where DashPay v2 has no such property. The stored DashPay contract is larger, so the values that depend on it move: the contract create and update fees in check_tx, the activation root of the v14 to v15 upgrade, the nullifier guard's root and settled-state hashes, and the latest root in rs-drive's deterministic root hash test. Two tests that fill a contact request at random now set the address to a valid length. Co-Authored-By: Claude Fable 5.2 --- .../src/execution/check_tx/v0/mod.rs | 45 +++++++++------- .../v0/mod.rs | 8 ++- .../v3/mod.rs | 2 +- .../batch/tests/document/dashpay_v3.rs | 51 +++++++++++++++++++ .../batch/tests/document/deletion.rs | 3 +- .../batch/tests/document/replacement.rs | 7 ++- .../token/shielded/nullifier_batch_guard.rs | 20 ++++---- .../rs-drive/tests/deterministic_root_hash.rs | 5 +- 8 files changed, 104 insertions(+), 37 deletions(-) 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 98364ed8658..f7fe26601a1 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 @@ -735,9 +735,10 @@ mod tests { // 1.8 times its bytes, which are byte-billed, and checking its compiled size is // charged per compiled byte // and a document type's schema size is billed at least the values the - // repeated-key walk read; the DashPay v3 schema adds its declarations and the - // privateContactRequest type (one more document type registration fee) - 26005728080 + // repeated-key walk read; the DashPay v3 schema adds its declarations, the + // privateContactRequest type (one more document type registration fee) and the + // contact request's encryptedShieldedAddress + 26005987270 ); let check_result = platform @@ -1093,8 +1094,9 @@ mod tests { // From protocol version 15 a document type's schema size is billed at least the // values the repeated-key walk read - // and DashPay v3's declarations add to the schema the validation is billed for - assert_eq!(processing_result.aggregated_fees().processing_fee, 346830); + // and DashPay v3's declarations and its contact request's shielded address add to the + // schema the validation is billed for + assert_eq!(processing_result.aggregated_fees().processing_fee, 346990); let check_result = platform .check_tx( @@ -1411,9 +1413,10 @@ mod tests { // 1.8 times its bytes, which are byte-billed, and checking its compiled size is // charged per compiled byte // and a document type's schema size is billed at least the values the - // repeated-key walk read; the DashPay v3 schema adds its declarations and the - // privateContactRequest type (one more document type registration fee) - 26011456160 + // repeated-key walk read; the DashPay v3 schema adds its declarations, the + // privateContactRequest type (one more document type registration fee) and the + // contact request's encryptedShieldedAddress + 26011974540 ); let check_result = platform @@ -1899,9 +1902,10 @@ mod tests { // 1.8 times its bytes, which are byte-billed, and checking its compiled size is // charged per compiled byte // and a document type's schema size is billed at least the values the - // repeated-key walk read; the DashPay v3 schema adds its declarations and the - // privateContactRequest type (one more document type registration fee) - 26005728080 + // repeated-key walk read; the DashPay v3 schema adds its declarations, the + // privateContactRequest type (one more document type registration fee) and the + // contact request's encryptedShieldedAddress + 26005987270 ); platform @@ -1999,9 +2003,10 @@ mod tests { // about 1.8 times its bytes, which are byte-billed, and checking its compiled size // is charged per compiled byte // and a document type's schema size is billed at least the values the - // repeated-key walk read; the DashPay v3 schema adds its declarations and the - // privateContactRequest type (one more document type registration fee) - 31006514040 + // repeated-key walk read; the DashPay v3 schema adds its declarations, the + // privateContactRequest type (one more document type registration fee) and the + // contact request's encryptedShieldedAddress + 31006811010 ); let check_result = platform @@ -2596,9 +2601,10 @@ mod tests { // 1.8 times its bytes, which are byte-billed, and checking its compiled size is // charged per compiled byte // and a document type's schema size is billed at least the values the - // repeated-key walk read; the DashPay v3 schema adds its declarations and the - // privateContactRequest type (one more document type registration fee) - 26005728080 + // repeated-key walk read; the DashPay v3 schema adds its declarations, the + // privateContactRequest type (one more document type registration fee) and the + // contact request's encryptedShieldedAddress + 26005987270 ); platform @@ -2723,8 +2729,9 @@ mod tests { // From protocol version 15 a document type's schema size is billed at least the // values the repeated-key walk read - // and DashPay v3's declarations add to the schema the validation is billed for - assert_eq!(processing_result.aggregated_fees().processing_fee, 448810); + // and DashPay v3's declarations and its contact request's shielded address add to the + // schema the validation is billed for + assert_eq!(processing_result.aggregated_fees().processing_fee, 448970); let check_result = platform .check_tx( 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 a0b099406b4..83ff22d3921 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 @@ -2707,8 +2707,12 @@ mod tests { .keys() .map(|path| path.as_str()) .collect::>(), - vec!["encryptedAccountLabel", "encryptedPublicKey"], - "the stored DashPay v3 keeps both encryptedFor declarations" + vec![ + "encryptedAccountLabel", + "encryptedPublicKey", + "encryptedShieldedAddress" + ], + "the stored DashPay v3 keeps its three encryptedFor declarations" ); assert_eq!( encrypted, diff --git a/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v3/mod.rs b/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v3/mod.rs index 3a23fd16b06..9d17d47d276 100644 --- a/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v3/mod.rs +++ b/packages/rs-drive-abci/src/execution/platform_events/protocol_upgrade/perform_events_on_first_block_of_protocol_change/v3/mod.rs @@ -256,7 +256,7 @@ mod tests { .unwrap(); assert_eq!( hex::encode(root), - "6322587059f91602b9f4d32542cc9787a266ed8b83a25bd3ce8f17e000222f7d", + "2981eedde98f2cb3cb39513953e0256a3f93570b5eaecec32f420ea6eaedb49d", "activation includes the current system contracts and retained-history migration", ); roots.push(root); diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/dashpay_v3.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/dashpay_v3.rs index 94f42fc45f7..e6c9bb0fb30 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/dashpay_v3.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/dashpay_v3.rs @@ -8,6 +8,9 @@ //! `toUserId` (40120), where the trigger refused it (40500). //! - An account label that is not an IV plus whole AES blocks: `encryptedFor` //! (10420), accepted up to protocol version 14. +//! - A contact request's shielded address, the optional `encryptedShieldedAddress` +//! DashPay v3 adds: an IV plus whole AES blocks (10420), and no property of +//! DashPay v2. //! - A profile payment address whose type byte is not 0x00 or 0x01, on create and //! on replace: the `byteAt` rules (10422), where the trigger refused it (40500). //! - A profile without either payment address or both, on create and on replace: @@ -126,6 +129,9 @@ mod dashpay_v3_tests { "encryptedAccountLabel", Value::Bytes(vec![8u8; label_length]), ); + // DashPay v3's optional shielded address, which the random fill gives any + // length from 64 to 80: left out unless a test sets it. + document.remove("encryptedShieldedAddress"); (document, entropy) } @@ -319,6 +325,51 @@ mod dashpay_v3_tests { ); } + /// New in DashPay v3: a contact request may carry the sender's shielded payment + /// address for this contact in 64 bytes, with 80 kept for a later encoding. + #[tokio::test] + async fn should_create_a_contact_request_carrying_an_encrypted_shielded_address() { + for length in [64, 80] { + let fixture = Fixture::latest(); + let (mut document, entropy) = fixture.contact_request(fixture.recipient.id(), 48); + document.set("encryptedShieldedAddress", Value::Bytes(vec![9u8; length])); + + assert_matches!( + fixture.create("contactRequest", document, entropy, 2).await, + StateTransitionExecutionResult::SuccessfulExecution { .. }, + "a shielded address field of {length} bytes" + ); + } + } + + /// The address is encrypted as the contact key is, so of the schema's 64 to 80 + /// bytes only an IV plus whole AES blocks is accepted. + #[tokio::test] + async fn should_refuse_a_shielded_address_that_is_not_an_iv_plus_whole_blocks() { + let fixture = Fixture::latest(); + let (mut document, entropy) = fixture.contact_request(fixture.recipient.id(), 48); + document.set("encryptedShieldedAddress", Value::Bytes(vec![9u8; 70])); + + assert_matches!( + paid_error(fixture.create("contactRequest", document, entropy, 2).await), + ConsensusError::BasicError(BasicError::InvalidEncryptedPropertyShapeError(e)) + if e.property() == "encryptedShieldedAddress" && e.actual_length() == 70 + ); + } + + /// Up to protocol version 14 DashPay v2 has no such property. + #[tokio::test] + async fn should_refuse_a_shielded_address_before_dashpay_v3() { + let fixture = Fixture::with_triggers(); + let (mut document, entropy) = fixture.contact_request(fixture.recipient.id(), 48); + document.set("encryptedShieldedAddress", Value::Bytes(vec![9u8; 64])); + + assert_matches!( + paid_error(fixture.create("contactRequest", document, entropy, 2).await), + ConsensusError::BasicError(BasicError::JsonSchemaError(_)) + ); + } + /// The profile trigger checked both addresses on create and on replace; from /// protocol version 15 the rules do. #[tokio::test] diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/deletion.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/deletion.rs index 430f7dfc475..16f3b873359 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/deletion.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/deletion.rs @@ -898,8 +898,9 @@ mod deletion_tests { document.set("senderKeyIndex", Value::U32(1)); document.set("accountReference", Value::U32(0)); // an IV plus whole AES blocks, as the label's `encryptedFor` requires from protocol - // version 15 + // version 15, and so for the shielded address DashPay v3 adds document.set("encryptedAccountLabel", Value::Bytes(vec![0u8; 48])); + document.set("encryptedShieldedAddress", Value::Bytes(vec![0u8; 64])); let mut altered_document = document.clone(); 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 df4a91b4dcb..ba9302c1f68 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 @@ -1316,9 +1316,11 @@ mod replacement_tests { document.set("senderKeyIndex", Value::U32(1)); document.set("accountReference", Value::U32(0)); // an IV plus whole AES blocks, as the label's `encryptedFor` requires from protocol - // version 15; earlier versions keep the generated label their fee pins were taken with + // version 15, and so for the shielded address DashPay v3 adds; earlier versions keep + // the generated label their fee pins were taken with if protocol_version >= 15 { document.set("encryptedAccountLabel", Value::Bytes(vec![0u8; 48])); + document.set("encryptedShieldedAddress", Value::Bytes(vec![0u8; 64])); } let mut altered_document = document.clone(); @@ -1431,7 +1433,8 @@ mod replacement_tests { async fn test_document_replace_on_document_type_that_is_not_mutable() { run_document_replace_on_document_type_that_is_not_mutable_at_protocol_version( PlatformVersion::latest().protocol_version, - 460740, // v14: stamped documents (see happy-path baseline note); from v15 a 48-byte label + 462060, // v14: stamped documents (see happy-path baseline note); from v15 a 48-byte label + // and the 64-byte shielded address DashPay v3 adds ) .await; } diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/token/shielded/nullifier_batch_guard.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/token/shielded/nullifier_batch_guard.rs index 38309a0ddc3..bb959e71e6e 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/token/shielded/nullifier_batch_guard.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/token/shielded/nullifier_batch_guard.rs @@ -731,7 +731,7 @@ async fn should_preserve_single_entry_full_processor_fees_and_result() { .value .unwrap() ), - "a78e27312332ff597d9bf527c061cf59e69a6b51563e0343400bfbef6e596c03" + "9769d48970c1e5130c426e09f8358f776b513412c5785f245a8e066bad2f982e" ); assert_eq!( pool.platform @@ -2182,39 +2182,39 @@ async fn should_preserve_single_entry_actions_errors_operations_and_settled_stat let (expected_validation, expected_settled) = match case { "shield" => ( "6a823c2db94612652926e6b9c1ae7feec9c2547dfd4cfc4e474318da1c16d59c", - "26456b2f2674b799c518535bc540b10958ced63cf02ca24ffe3575d5069cbfee", + "04dc53ad314155e410bc3cd506f34f28e75625a4391937d3cb1758ff63ce5838", ), "valid-payment" => ( "9388d5cf63c4a571b9fb009679e2e34d0b681acc88f0f5195e7287c7efbd92f7", - "75eee0fb5505f957be07f65fd78158e36c451e10303c6b25a8d37ce799cebe81", + "396e76ad676ba17bec847fbb1ef225fe485809bc222d5842c63a41eeb757b32f", ), "failed-payment" => ( "d9b5fe191841bea952494f2a45e3833f925f4d367a1937b2ef1235a1aa01f51e", - "5ebbe8df6322d78e259cfbac017308edec9f0faac1c6ba137135474d0ff0c1ef", + "8899321ecac82e845797177460c5f83b224674d38b6003363b217311850d3cb5", ), "within-bundle-repeat" => ( "8023e03a697a20f6a78396a05503a4bc583ca8f69e19bd7ee07a6ae0ce7be478", - "ffabe9541bddcbcfa55e223f2611e7aa4691d9bc43772c6b17e0305ed7d97121", + "c8fcf0e9fa3a96fdb8463febec06ddeb61b6c763b7c28665ede1577820528a56", ), "stored-repeat" => ( "05652ac85c972902e8c09d20a7d8586e17e9434a478b335da136ad85f73def01", - "5205a8992fd53d30138484eb9f04e011a3b4c2f7a9fc464a04d6f1ce5ef34a63", + "e0dc5783e43e08036276953a68626bfd9fcd71dc200766cd8a0bafd03b8ac7a8", ), "open-mint-group" => ( "5c68381297c9bf68c5e85ebe6bb9e0f1289e2c07718eecfb5e6773d6009455bb", - "b316371c068be93be5a58fce59c175ef7c6c32028103b4b031d4fe45a373ac16", + "d8682a642fd590a6299b6284e0242b62b9e9cfc0c0dce62ea81a8b92f6707b58", ), "closing-mint-group" => ( "2cedc16732c76e0605b5f46085db3d69c12936a5af55a2a82f52ec9e9ca67e38", - "1e6d20b67fcefef863533d5d3d1b708c2b3a2044c5397c4e0a9efbb01722cac7", + "4ad2894c9fd3963bec44d92a21eb76cdfaf93db72a3023d4480fd15e681f8cef", ), "open-burn-group" => ( "e664a045f020ff84de1ca98f364fbabccfc141ad46aa82c79491a340bb0db5f8", - "04722561bf7430db3765880d08ea128b11b249e39c1ed607c4013e0f3ff17e34", + "1a9a2f3922c12bbb4f306931c5cfca9c7725ccadc440e572778f08eb5c440be8", ), "closing-burn-group" => ( "93e1732286f168c4a91d2765931e181c5721bfca1bfd5f93b8baacca03e00b2b", - "898114233f06416d17727a955501c2ba7154236af14b3e1671500759d4861336", + "4675f7f029799a05810021873af3884d7747b5b80634c764cc6ca8ab0cc1a584", ), _ => unreachable!("enumerated characterization case"), }; diff --git a/packages/rs-drive/tests/deterministic_root_hash.rs b/packages/rs-drive/tests/deterministic_root_hash.rs index 08786ef3e2f..fdb4398f2b3 100644 --- a/packages/rs-drive/tests/deterministic_root_hash.rs +++ b/packages/rs-drive/tests/deterministic_root_hash.rs @@ -315,8 +315,9 @@ mod tests { // document types beside its schemas, and is DashPay v3, which declares the checks of // its data triggers and adds the private `privateContactRequest` type, whose store // the insert creates, at chunk power 10 (605-byte stored entries under the 1 MiB - // chunk target of `SYSTEM_LIMITS_V5`). - _ => "adb6a2e6be5a67bb2730c27ca9a63cc4cacf485b634ec4a0ad998b0da508a7e2", + // chunk target of `SYSTEM_LIMITS_V5`), and a contact request's optional + // `encryptedShieldedAddress`. + _ => "3ef193e9d125d0e6cce24e208e1c0e9d723e7226db1150ae6dbcc1a06622c3f3", }; assert_eq!( From f1dbeb240996af947175ffcc5aa998caef47a29b Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Thu, 12 Nov 2026 20:23:49 +0700 Subject: [PATCH 3/5] test(dpp): store DashPay v3 with its shielded address in the stored contract fixture The fixture pins the bytes protocol version 15 stores each system contract in. DashPay v3's contact request has one more property, so its stored form grows from 10,182 to 10,805 bytes. Regenerated as the fixture's README allows while protocol version 15 is unreleased; only the `system Dashpay` line changes. Co-Authored-By: Claude Fable 5.2 --- packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl b/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl index 791fc5c583e..b5e2c7aad85 100644 --- a/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl +++ b/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl @@ -1,7 +1,7 @@ {"contract":"system Withdrawals","sha256":"e2e5dc10ce6bfc80941799bfc0c2d9db3c81863efe5f2b908c07f133c32b63b6","indexStructures":"8c2a2ac7665d9b16ae332240eca722d874d447b5bcb6b53c67491bf46738c18c","bytes":"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"} {"contract":"system MasternodeRewards","sha256":"8e6fca6a3f0251ea6a3037190fb2c47a576e4d4d02752fc66762c37702dd1c81","indexStructures":"32b6598dc9d815da658a6a69c9bd2f5e4cb9d57731901b10a51c8565eb28d0f1","bytes":"Agys4gUkZpOnyBVlI2INqpN9LyJHk0Rj7rAf9yGVkJWMAgAAAAABAQAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQtyZXdhcmRTaGFyZRYGEgtkZXNjcmlwdGlvbhJAU2hhcmUgc3BlY2lmaWVkIHBlcmNlbnRhZ2Ugb2YgbWFzdGVybm9kZSByZXdhcmRzIHdpdGggaWRlbnRpdGllcxIEdHlwZRIGb2JqZWN0EgdpbmRpY2VzFQIWAxIEbmFtZRIRb3duZXJJZEFuZFBheVRvSWQSCnByb3BlcnRpZXMVAhYBEggkb3duZXJJZBIDYXNjFgESB3BheVRvSWQSA2FzYxIGdW5pcXVlEwEWAhIEbmFtZRIHb3duZXJJZBIKcHJvcGVydGllcxUBFgESCCRvd25lcklkEgNhc2MSCnByb3BlcnRpZXMWAhIHcGF5VG9JZBYHEgtkZXNjcmlwdGlvbhIfSWRlbnRpZmllciB0byBzaGFyZSByZXdhcmQgd2l0aBIEdHlwZRIFYXJyYXkSCWJ5dGVBcnJheRMBEghtaW5JdGVtcwIgEghtYXhJdGVtcwIgEhBjb250ZW50TWVkaWFUeXBlEiFhcHBsaWNhdGlvbi94LmRhc2guZHBwLmlkZW50aWZpZXISCHBvc2l0aW9uAgASCnBlcmNlbnRhZ2UWBRILZGVzY3JpcHRpb24SGlJld2FyZCBwZXJjZW50YWdlIHRvIHNoYXJlEgR0eXBlEgdpbnRlZ2VyEgdtaW5pbXVtAgESB21heGltdW0C+ycQEghwb3NpdGlvbgIBEghyZXF1aXJlZBUCEgdwYXlUb0lkEgpwZXJjZW50YWdlEhRhZGRpdGlvbmFsUHJvcGVydGllcxMAAAAAAAAAAAAAAAELcmV3YXJkU2hhcmUAAgdwYXlUb0lkDQEAAAAAAAAKcGVyY2VudGFnZQMBAAAAAAAAAgdwYXlUb0lkDQEAAAAAAAAKcGVyY2VudGFnZQMBAAAAAAAAAgdvd25lcklkB293bmVySWQBCCRvd25lcklkAQABAAAAAAAAAAAAAAAAAAAAAAAAAAARb3duZXJJZEFuZFBheVRvSWQRb3duZXJJZEFuZFBheVRvSWQCCCRvd25lcklkAQdwYXlUb0lkAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQdwYXlUb0lkAAIHcGF5VG9JZApwZXJjZW50YWdlAAAAAAAAAAAAAQEAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAZQABAAIAAAEBAgdwYXlUb0lkAAEAAwAAAAEAAAEgASAAAQAAAApwZXJjZW50YWdlAAEABgAAAAAAAQECAQEC+ycQAAAAAAEAAQIHcGF5VG9JZApwZXJjZW50YWdlAAAAAAAAAAAA"} {"contract":"system DPNS","sha256":"a2843864eac10ce99cdb9c2f8c88dfa89895f88e22dd713c1b5f3aa3d1d67f76","indexStructures":"17bffbf629fec74c2122a325580231d6f460e320172e90eb26d05cf792780353","bytes":"AuZoxlmvZq7h5ywYbd57W34KHXEqCcQNVyH2Ir9TxTFVAgAAAAABAQAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZkb21haW4WDxIQZG9jdW1lbnRzTXV0YWJsZRMAEgxjYW5CZURlbGV0ZWQTABIMdHJhbnNmZXJhYmxlAgESCXRyYWRlTW9kZQIBEhRrZWVwc1RyYW5zZmVySGlzdG9yeRMBEhRrZWVwc1B1cmNoYXNlSGlzdG9yeRMBEhNrZWVwc1ByaWNpbmdIaXN0b3J5EwESBHR5cGUSBm9iamVjdBIHaW5kaWNlcxUCFgQSBG5hbWUSEnBhcmVudE5hbWVBbmRMYWJlbBIKcHJvcGVydGllcxUCFgESGm5vcm1hbGl6ZWRQYXJlbnREb21haW5OYW1lEgNhc2MWARIPbm9ybWFsaXplZExhYmVsEgNhc2MSBnVuaXF1ZRMBEgljb250ZXN0ZWQWAxIMZmllbGRNYXRjaGVzFQEWAhIFZmllbGQSD25vcm1hbGl6ZWRMYWJlbBIMcmVnZXhQYXR0ZXJuEhNeW2EtekEtWjAxLV17MywxOX0kEgpyZXNvbHV0aW9uAgASC2Rlc2NyaXB0aW9uEk5Ob3JtYWxpemVkIGxhYmVscyBvZiAzIHRvIDE5IGEteiwgMCwgMSBvciAtIGNoYXJhY3RlcnMgZ28gdG8gYSBtYXN0ZXJub2RlIHZvdGUWAxIEbmFtZRIKaWRlbnRpdHlJZBIObnVsbFNlYXJjaGFibGUTABIKcHJvcGVydGllcxUBFgESEHJlY29yZHMuaWRlbnRpdHkSA2FzYxIPY3JlYXRvclJlZmVyc1RvFgYSBHR5cGUSEWRlbGV0YWJsZURvY3VtZW50Egxkb2N1bWVudFR5cGUSCHByZW9yZGVyEgZmaW5kQnkWAhIIJG93bmVySWQSCCRvd25lcklkEghuYW1lSGFzaBYCEghmdW5jdGlvbhIQc3lzLmhhc2guc2hhMjU2ZBIGcGFyYW1zFQMSD25vcm1hbGl6ZWRMYWJlbBYBEgVjb25zdBIBLhIabm9ybWFsaXplZFBhcmVudERvbWFpbk5hbWUSBXdoZXJlFgESCCRvd25lcklkEggkb3duZXJJZBILY29uc3RyYWludHMWAhIQbWluaW11bUFnZUJsb2NrcwIBEgtjaG9vc2VGaXJzdBYDEgVhbW9uZxIIbmFtZUhhc2gSCXZhbGlkV2hlbhYBEg1vd25lck5hbWVIYXNoFgISCGZ1bmN0aW9uEhBzeXMuaGFzaC5zaGEyNTZkEgZwYXJhbXMVBBIIJG93bmVySWQSD25vcm1hbGl6ZWRMYWJlbBYBEgVjb25zdBIBLhIabm9ybWFsaXplZFBhcmVudERvbWFpbk5hbWUSAmJ5FQESFSRjcmVhdGVkQXRCbG9ja0hlaWdodBIHY29uc3VtZRMBEgpwcm9wZXJ0aWVzFgcSBWxhYmVsFgYSBHR5cGUSBnN0cmluZxIHcGF0dGVybhIqXlthLXpBLVowLTldW2EtekEtWjAtOS1dezAsNjF9W2EtekEtWjAtOV0kEgltaW5MZW5ndGgCAxIJbWF4TGVuZ3RoAj8SCHBvc2l0aW9uAgASC2Rlc2NyaXB0aW9uEhFMYWJlbCwgZS5nLiAnQm9iJxIPbm9ybWFsaXplZExhYmVsFgUSBHR5cGUSBnN0cmluZxIJbWF4TGVuZ3RoAj8SDWdlbmVyYXRlZEZyb20WAhIIZnVuY3Rpb24SLHN5cy5zdHJpbmdUcmFuc2Zvcm1hdGlvbnMuaG9tb2dyYXBoU2FmZUFTQ0lJEgZwYXJhbXMVARIFbGFiZWwSCHBvc2l0aW9uAgESC2Rlc2NyaXB0aW9uEj1HZW5lcmF0ZWQ6IGxhYmVsIGxvd2VyY2FzZWQsIG8gdG8gMCwgaSBhbmQgbCB0byAxLCBlLmcuICdiMGInEhBwYXJlbnREb21haW5OYW1lFgYSBHR5cGUSBnN0cmluZxIHcGF0dGVybhItXiR8XlthLXpBLVowLTldW2EtekEtWjAtOS1dezAsNjF9W2EtekEtWjAtOV0kEgltaW5MZW5ndGgCABIJbWF4TGVuZ3RoAj8SCHBvc2l0aW9uAgISC2Rlc2NyaXB0aW9uEh9QYXJlbnQgZG9tYWluIG5hbWUsIGUuZy4gJ2Rhc2gnEhpub3JtYWxpemVkUGFyZW50RG9tYWluTmFtZRYFEgR0eXBlEgZzdHJpbmcSCW1heExlbmd0aAI/Eg1nZW5lcmF0ZWRGcm9tFgISCGZ1bmN0aW9uEixzeXMuc3RyaW5nVHJhbnNmb3JtYXRpb25zLmhvbW9ncmFwaFNhZmVBU0NJSRIGcGFyYW1zFQESEHBhcmVudERvbWFpbk5hbWUSCHBvc2l0aW9uAgMSC2Rlc2NyaXB0aW9uEjtHZW5lcmF0ZWQ6IHBhcmVudERvbWFpbk5hbWUgbm9ybWFsaXplZCBsaWtlIG5vcm1hbGl6ZWRMYWJlbBIMcHJlb3JkZXJTYWx0FgQSBHR5cGUSBWJ5dGVzEgRzaXplAiASCHBvc2l0aW9uAgQSC2Rlc2NyaXB0aW9uEj5VbnVzZWQgZnJvbSB2Mzsga2VwdCBzbyBkb21haW5zIHdyaXR0ZW4gdW5kZXIgdjEgYW5kIHYyIGRlY29kZRIHcmVjb3JkcxYFEgR0eXBlEgZvYmplY3QSCnByb3BlcnRpZXMWARIIaWRlbnRpdHkWAxIEdHlwZRIKaWRlbnRpZmllchIIcG9zaXRpb24CARILZGVzY3JpcHRpb24SNklkZW50aXR5IHRoZSBuYW1lIHJlc29sdmVzIHRvOyBpdHMgb3duZXIncyBhdCBjcmVhdGlvbhINbWluUHJvcGVydGllcwIBEghwb3NpdGlvbgIFEhRhZGRpdGlvbmFsUHJvcGVydGllcxMAEg5zdWJkb21haW5SdWxlcxYGEgR0eXBlEgZvYmplY3QSCnByb3BlcnRpZXMWARIPYWxsb3dTdWJkb21haW5zFgMSBHR5cGUSB2Jvb2xlYW4SC2Rlc2NyaXB0aW9uEj1BbnlvbmUgbWF5IGNyZWF0ZSBzdWJkb21haW5zICh0cnVlKSBvciBvbmx5IHRoZSBvd25lciAoZmFsc2UpEghwb3NpdGlvbgIAEghwb3NpdGlvbgIGEgtkZXNjcmlwdGlvbhIPU3ViZG9tYWluIHJ1bGVzEhRhZGRpdGlvbmFsUHJvcGVydGllcxMAEghyZXF1aXJlZBUBEg9hbGxvd1N1YmRvbWFpbnMSCHJlcXVpcmVkFQgSCiRjcmVhdGVkQXQSCiR1cGRhdGVkQXQSDiR0cmFuc2ZlcnJlZEF0EgVsYWJlbBIPbm9ybWFsaXplZExhYmVsEhpub3JtYWxpemVkUGFyZW50RG9tYWluTmFtZRIHcmVjb3JkcxIOc3ViZG9tYWluUnVsZXMSCXRyYW5zaWVudBUBEgxwcmVvcmRlclNhbHQSE3Byb3BlcnR5Q29uc3RyYWludHMWARIWcmVjb3Jkc0lkZW50aXR5SXNPd25lchYBEgZpZlRoZW4VAhYBEgVlcXVhbBUCEg4kdHJhbnNmZXJyZWRBdBIKJGNyZWF0ZWRBdBYBEgVlcXVhbBUCEhByZWNvcmRzLmlkZW50aXR5Eggkb3duZXJJZBIUYWRkaXRpb25hbFByb3BlcnRpZXMTAAhwcmVvcmRlchYJEhBkb2N1bWVudHNNdXRhYmxlEwASDGNhbkJlRGVsZXRlZBMBEgN0dGwC+w4QEgR0eXBlEgZvYmplY3QSB2luZGljZXMVAxYDEgRuYW1lEhBvd25lckFuZE5hbWVIYXNoEgpwcm9wZXJ0aWVzFQIWARIIJG93bmVySWQSA2FzYxYBEghuYW1lSGFzaBIDYXNjEgZ1bmlxdWUTARYCEgRuYW1lEhFuYW1lSGFzaEFuZEhlaWdodBIKcHJvcGVydGllcxUCFgESCG5hbWVIYXNoEgNhc2MWARIVJGNyZWF0ZWRBdEJsb2NrSGVpZ2h0EgNhc2MWAxIEbmFtZRIIbmFtZUhhc2gSCnByb3BlcnRpZXMVARYBEghuYW1lSGFzaBIDYXNjEgljb3VudGFibGUSCWNvdW50YWJsZRIKcHJvcGVydGllcxYCEg1vd25lck5hbWVIYXNoFgQSBHR5cGUSBWJ5dGVzEgRzaXplAiASCHBvc2l0aW9uAgASC2Rlc2NyaXB0aW9uEkxzaGEyNTZkIG9mIG93bmVyIGlkLCBub3JtYWxpemVkIGxhYmVsLCAnLicgYW5kIG5vcm1hbGl6ZWQgcGFyZW50IGRvbWFpbiBuYW1lEghuYW1lSGFzaBYEEgR0eXBlEgVieXRlcxIEc2l6ZQIgEghwb3NpdGlvbgIBEgtkZXNjcmlwdGlvbhJCc2hhMjU2ZCBvZiBub3JtYWxpemVkIGxhYmVsLCAnLicgYW5kIG5vcm1hbGl6ZWQgcGFyZW50IGRvbWFpbiBuYW1lEghyZXF1aXJlZBUEEgokY3JlYXRlZEF0EhUkY3JlYXRlZEF0QmxvY2tIZWlnaHQSDW93bmVyTmFtZUhhc2gSCG5hbWVIYXNoEhNwcm9wZXJ0eUNvbnN0cmFpbnRzFgESFmF0TW9zdEFUaG91c2FuZFBlck5hbWUWARIPbGVzc1RoYW5PckVxdWFsFQIWARIHY291bnRPZhUCEghwcmVvcmRlchYBEghuYW1lSGFzaBIIbmFtZUhhc2gC+wPoEhRhZGRpdGlvbmFsUHJvcGVydGllcxMAAAAAAAAAAAAAAAIGZG9tYWluAAcFbGFiZWwLAQMBPwABAAAAAAAAD25vcm1hbGl6ZWRMYWJlbAsAAT8AAQAAAAABAAIBBWxhYmVsABBwYXJlbnREb21haW5OYW1lCwEAAT8AAAAAAAAAABpub3JtYWxpemVkUGFyZW50RG9tYWluTmFtZQsAAT8AAQAAAAABAAIBEHBhcmVudERvbWFpbk5hbWUADHByZW9yZGVyU2FsdAwBIAEgAAEAAAAAAAdyZWNvcmRzEAEIaWRlbnRpdHkNAAAAAAAAAAEAAAAAAAAOc3ViZG9tYWluUnVsZXMQAQ9hbGxvd1N1YmRvbWFpbnMOAQAAAAAAAAEAAAAAAAAHBWxhYmVsCwEDAT8AAQAAAAAAAA9ub3JtYWxpemVkTGFiZWwLAAE/AAEAAAAAAQACAQVsYWJlbAAQcGFyZW50RG9tYWluTmFtZQsBAAE/AAAAAAAAAAAabm9ybWFsaXplZFBhcmVudERvbWFpbk5hbWULAAE/AAEAAAAAAQACARBwYXJlbnREb21haW5OYW1lAAxwcmVvcmRlclNhbHQMASABIAABAAAAAAAQcmVjb3Jkcy5pZGVudGl0eQ0AAAAAAAAAHnN1YmRvbWFpblJ1bGVzLmFsbG93U3ViZG9tYWlucw4BAAAAAAAAAgppZGVudGl0eUlkCmlkZW50aXR5SWQBEHJlY29yZHMuaWRlbnRpdHkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJwYXJlbnROYW1lQW5kTGFiZWwScGFyZW50TmFtZUFuZExhYmVsAhpub3JtYWxpemVkUGFyZW50RG9tYWluTmFtZQEPbm9ybWFsaXplZExhYmVsAQEBAQEPbm9ybWFsaXplZExhYmVsABNeW2EtekEtWjAxLV17MywxOX0kAAAAAAAAAAAAAAAAAAAAAAAAAAAAARByZWNvcmRzLmlkZW50aXR5AQxwcmVvcmRlclNhbHQJCiRjcmVhdGVkQXQOJHRyYW5zZmVycmVkQXQKJHVwZGF0ZWRBdAVsYWJlbA9ub3JtYWxpemVkTGFiZWwabm9ybWFsaXplZFBhcmVudERvbWFpbk5hbWUHcmVjb3Jkcw5zdWJkb21haW5SdWxlcx5zdWJkb21haW5SdWxlcy5hbGxvd1N1YmRvbWFpbnMBDHByZW9yZGVyU2FsdAAAAAAAAQEBAAAAAQEAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAABCgAIcHJlb3JkZXIBCCRvd25lcklkCCRvd25lcklkAAIIJG93bmVySWQBCG5hbWVIYXNoAwADAQ9ub3JtYWxpemVkTGFiZWwCAS4BGm5vcm1hbGl6ZWRQYXJlbnREb21haW5OYW1lAQEBAQhuYW1lSGFzaA1vd25lck5hbWVIYXNoAAQDAQ9ub3JtYWxpemVkTGFiZWwCAS4BGm5vcm1hbGl6ZWRQYXJlbnREb21haW5OYW1lARUkY3JlYXRlZEF0QmxvY2tIZWlnaHQBARZyZWNvcmRzSWRlbnRpdHlJc093bmVyEAAABQACAAUAAAAGABByZWNvcmRzLmlkZW50aXR5CCRvd25lcklkAAAAAAIA+wHhAAEAAgAAAQEHBWxhYmVsAAEABQAAAAABAQMBPwABKl5bYS16QS1aMC05XVthLXpBLVowLTktXXswLDYxfVthLXpBLVowLTldJAAAD25vcm1hbGl6ZWRMYWJlbAABAAUAAAAAAQABPwAAAAAQcGFyZW50RG9tYWluTmFtZQABAAUAAAAAAQEAAT8AAS1eJHxeW2EtekEtWjAtOV1bYS16QS1aMC05LV17MCw2MX1bYS16QS1aMC05XSQAABpub3JtYWxpemVkUGFyZW50RG9tYWluTmFtZQABAAUAAAAAAQABPwAAAAAMcHJlb3JkZXJTYWx0AAEAAwAAAAEAAAEgASAAAQAAAAdyZWNvcmRzAAEAAgAAAQEBCGlkZW50aXR5AAEAAwAAAAEAAAEgASAAAQAAAAEAAAEBAAAAAAAADnN1YmRvbWFpblJ1bGVzAAEAAgAAAQEBD2FsbG93U3ViZG9tYWlucwABAAEAAAAAAAAAAQABAQ9hbGxvd1N1YmRvbWFpbnMAAAAAAAAAAQABBQVsYWJlbA9ub3JtYWxpemVkTGFiZWwabm9ybWFsaXplZFBhcmVudERvbWFpbk5hbWUHcmVjb3Jkcw5zdWJkb21haW5SdWxlcwAAAAAAAAAAAAhwcmVvcmRlcgACDW93bmVyTmFtZUhhc2gMASABIAEAAAAAAAAIbmFtZUhhc2gMASABIAEAAAAAAAACDW93bmVyTmFtZUhhc2gMASABIAEAAAAAAAAIbmFtZUhhc2gMASABIAEAAAAAAAADCG5hbWVIYXNoCG5hbWVIYXNoAQhuYW1lSGFzaAEAAQABAAAAAAAAAAAAAAAAAAAAAAAAEW5hbWVIYXNoQW5kSGVpZ2h0EW5hbWVIYXNoQW5kSGVpZ2h0AghuYW1lSGFzaAEVJGNyZWF0ZWRBdEJsb2NrSGVpZ2h0AQABAAAAAAAAAAAAAAAAAAAAAAAAAAAQb3duZXJBbmROYW1lSGFzaBBvd25lckFuZE5hbWVIYXNoAggkb3duZXJJZAEIbmFtZUhhc2gBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAghuYW1lSGFzaA1vd25lck5hbWVIYXNoBAokY3JlYXRlZEF0FSRjcmVhdGVkQXRCbG9ja0hlaWdodAhuYW1lSGFzaA1vd25lck5hbWVIYXNoAAAAAAAAAAAAAAEAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAARZhdE1vc3RBVGhvdXNhbmRQZXJOYW1lAAMPAAhwcmVvcmRlcgEIbmFtZUhhc2gACG5hbWVIYXNoAQIBAPsH0AAB+w4QAAIAagABAAIAAAEBAg1vd25lck5hbWVIYXNoAAEAAwAAAAEAAAEgASAAAQAAAAhuYW1lSGFzaAABAAMAAAABAAABIAEgAAEAAAABAAECDW93bmVyTmFtZUhhc2gIbmFtZUhhc2gAAAAAAAAAAAA="} -{"contract":"system Dashpay","sha256":"cec07d7a3855d4ebf8d6625ef1ec11cc3a670a87b4761c00f04276e7abe1b9b2","indexStructures":"48aae4c52a6e088fcb54110b1d769a4807783d27e3c05aac332499b315708d8a","bytes":"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"} +{"contract":"system Dashpay","sha256":"c4980b7805fa4e9798cf313c548b2e7b3ca0c6fa229c51347601fe32e30a4e02","indexStructures":"48aae4c52a6e088fcb54110b1d769a4807783d27e3c05aac332499b315708d8a","bytes":"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"} {"contract":"system WalletUtils","sha256":"44f8ae6fdd4b4dc645a70255916f1bfb6d987d42daf7fbcec1484c801cd766f6","indexStructures":"55ac5ba653b687c33139c7b53b8f78e26992dfc66897a27630d0281f60e843ee","bytes":"AlwUDmVcAmW7wqgIcW3hhHmFE1kYrVHN/Qt2ZkupW6N8AgAAAAABAQAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQp0eE1ldGFkYXRhFgcSBHR5cGUSBm9iamVjdBIQZG9jdW1lbnRzTXV0YWJsZRMBEgxjYW5CZURlbGV0ZWQTARIHaW5kaWNlcxUBFgISBG5hbWUSB3VwZGF0ZWQSCnByb3BlcnRpZXMVAhYBEggkb3duZXJJZBIDYXNjFgESCiR1cGRhdGVkQXQSA2FzYxIKcHJvcGVydGllcxYDEghrZXlJbmRleBYEEgR0eXBlEgdpbnRlZ2VyEgdtaW5pbXVtAgASC2Rlc2NyaXB0aW9uEjdUaGUgZGVyaXZhdGlvbiBpbmRleCB1c2VkIHRvIGNyZWF0ZSB0aGUgZW5jcnlwdGlvbiBrZXkuEghwb3NpdGlvbgIAEhJlbmNyeXB0aW9uS2V5SW5kZXgWBBIEdHlwZRIHaW50ZWdlchIHbWluaW11bQIAEgtkZXNjcmlwdGlvbhJoVGhlIHNlY29uZGFyeSBpbmRleCB1c2VkIHRvIGRlcml2ZSB0aGUgZW5jcnlwdGlvbiBrZXkgdGhhdCBpcyB1c2VkIHRvIGVuY3J5cHQgYW5kIGRlY3J5cHQgZW5jcnlwdGVkRGF0YS4SCHBvc2l0aW9uAgESEWVuY3J5cHRlZE1ldGFkYXRhFgYSBHR5cGUSBWFycmF5EglieXRlQXJyYXkTARIIbWluSXRlbXMCIBIIbWF4SXRlbXMC+xAAEgtkZXNjcmlwdGlvbhIkZW5jcnlwdGVkIG1ldGFkYXRhIHVzaW5nIEFFUy1DQkMtMjU2Eghwb3NpdGlvbgICEghyZXF1aXJlZBUEEghrZXlJbmRleBISZW5jcnlwdGlvbktleUluZGV4EhFlbmNyeXB0ZWRNZXRhZGF0YRIKJHVwZGF0ZWRBdBIUYWRkaXRpb25hbFByb3BlcnRpZXMTAAAAAAAAAAAAAAABCnR4TWV0YWRhdGEAAwhrZXlJbmRleAMBAAAAAAAAEmVuY3J5cHRpb25LZXlJbmRleAMBAAAAAAAAEWVuY3J5cHRlZE1ldGFkYXRhDAEgAfsQAAEAAAAAAAADCGtleUluZGV4AwEAAAAAAAASZW5jcnlwdGlvbktleUluZGV4AwEAAAAAAAARZW5jcnlwdGVkTWV0YWRhdGEMASAB+xAAAQAAAAAAAAEHdXBkYXRlZAd1cGRhdGVkAggkb3duZXJJZAEKJHVwZGF0ZWRBdAEAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEWVuY3J5cHRlZE1ldGFkYXRhBAokdXBkYXRlZEF0EWVuY3J5cHRlZE1ldGFkYXRhEmVuY3J5cHRpb25LZXlJbmRleAhrZXlJbmRleAAAAAAAAAAAAAEBAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAKsAAQACAAABAQMIa2V5SW5kZXgAAQAGAAAAAAABAQIAAAAAAAASZW5jcnlwdGlvbktleUluZGV4AAEABgAAAAAAAQECAAAAAAAAEWVuY3J5cHRlZE1ldGFkYXRhAAEAAwAAAAEAAAEgAfsQAAABAAAAAQABAwhrZXlJbmRleBJlbmNyeXB0aW9uS2V5SW5kZXgRZW5jcnlwdGVkTWV0YWRhdGEAAAAAAAAAAAA="} {"contract":"system TokenHistory","sha256":"fe76e37de0436c36f29d70dd0189bf52306637972337424e8c5c5b650fedee92","indexStructures":"859602c19facd2b7d69afa1fe4508ef1b8a4a4cbe2647a0054197f8b62e49ff1","bytes":"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"} {"contract":"system KeywordSearch","sha256":"b4e11bd204ed7b15db62cf88e0eb6acb2c4a7d800821818a673aa9fb79face8a","indexStructures":"9e7e3d1f61ec253eff3272bc5ab07c4dd3d166e4149679878c479e6d0a6b22ed","bytes":"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"} From cfc246dd52a762427ddbddf6d3b88804de81725a Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Thu, 12 Nov 2026 23:07:43 +0700 Subject: [PATCH 4/5] docs(platform): say that consensus accepts an 80-byte shielded address field The protocol version note, the contract crate's comment and the book read as if only 64 bytes were valid. Consensus accepts 64 or 80 bytes, the two lengths in the schema's range that are an IV plus whole AES blocks, and refuses the rest. Writing 64 and keeping 80 for a later encoding is a wallet convention. Co-Authored-By: Claude Fable 5.2 --- book/src/evo-sdk/dashpay-contact-requests.md | 7 ++++--- packages/dashpay-contract/src/v3/mod.rs | 7 ++++--- packages/rs-platform-version/src/version/v15.rs | 11 ++++++----- 3 files changed, 14 insertions(+), 11 deletions(-) diff --git a/book/src/evo-sdk/dashpay-contact-requests.md b/book/src/evo-sdk/dashpay-contact-requests.md index 48381c9dcfb..85756baba52 100644 --- a/book/src/evo-sdk/dashpay-contact-requests.md +++ b/book/src/evo-sdk/dashpay-contact-requests.md @@ -56,9 +56,10 @@ contact, encrypted with the same shared secret. It is exactly 64 bytes: - 48 bytes: AES-CBC ciphertext of the 43-byte address (an 11-byte diversifier followed by a 32-byte transmission key) -The contract accepts 64 to 80 bytes and keeps the 80-byte length for a later -encoding. A sender gives each contact a different address, so a payment that -arrives on one is attributed to that contact. +The contract accepts 64 or 80 bytes, the two lengths in its range that are an +IV plus whole blocks. Wallets write 64 and keep 80 for a later encoding. A +sender gives each contact a different address, so a payment that arrives on +one is attributed to that contact. From protocol version 15 the DashPay contract (v3) states these checks in its schema, and a contact request that fails one is refused (and the fee charged): diff --git a/packages/dashpay-contract/src/v3/mod.rs b/packages/dashpay-contract/src/v3/mod.rs index 6aaa59e2b09..0d26b13df6d 100644 --- a/packages/dashpay-contract/src/v3/mod.rs +++ b/packages/dashpay-contract/src/v3/mod.rs @@ -23,9 +23,10 @@ use serde_json::Value; // // - `contactRequest.encryptedShieldedAddress`, optional and last in position: the // sender's shielded payment address for this contact (43 bytes), encrypted as -// `encryptedPublicKey` is (`encryptedFor`). That is an IV and three AES blocks, -// 64 bytes; the 80-byte length is kept for a later encoding. A contact request -// stored before the property existed ends before it and reads back without it. +// `encryptedPublicKey` is (`encryptedFor`). That is 64 bytes, an IV and three AES +// blocks. The contract also accepts 80 bytes, an IV and four blocks, which wallets +// keep for a later encoding. A contact request stored before the property existed +// ends before it and reads back without it. // // And it adds one type: // diff --git a/packages/rs-platform-version/src/version/v15.rs b/packages/rs-platform-version/src/version/v15.rs index d93d84a6db5..34cbba3d521 100644 --- a/packages/rs-platform-version/src/version/v15.rs +++ b/packages/rs-platform-version/src/version/v15.rs @@ -556,11 +556,12 @@ pub const PROTOCOL_VERSION_15: ProtocolVersion = 15; /// DashPay v2 and bindings 2, and earlier versions the contract and bindings they had. /// DashPay v3 also gives a `contactRequest` one property, the optional /// `encryptedShieldedAddress`, last in position: the sender's shielded payment address -/// for this contact (43 bytes) under the same `encryptedFor` as `encryptedPublicKey`, -/// so 64 bytes, an IV and three AES blocks, with 80 kept for a later encoding (any -/// other length from 64 to 80 is `InvalidEncryptedPropertyShapeError`, 10420). A -/// contact request stored under v1 or v2 ends before the property and reads back -/// without it. +/// for this contact (43 bytes) under the same `encryptedFor` as `encryptedPublicKey`. +/// Consensus accepts 64 or 80 bytes, an IV plus three or four AES blocks, and refuses +/// every other length from 64 to 80 (`InvalidEncryptedPropertyShapeError`, 10420). +/// A 43-byte address encrypts to 64 bytes, which wallets write; they keep 80 for a +/// later encoding, a convention consensus does not check. A contact request stored +/// under v1 or v2 ends before the property and reads back without it. /// DashPay v3 also declares `privateContactRequest`, a private type (note 13) of 589-byte /// entries whose properties describe a contact request only its recipient can read: /// `accountReference`, the DIP-15 compact `extendedPublicKey` (69 bytes), and the optional From 71ecfc28b818fd342df91449baf3f88a14474654 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Fri, 13 Nov 2026 00:27:02 +0700 Subject: [PATCH 5/5] docs(platform): describe 64 bytes as the current encoding of the shielded address field The book said the field is exactly 64 bytes, then that the contract accepts 64 or 80. It now says wallets write 64 bytes today, that the contract also accepts 80, and that a reader ignores a value it cannot decode. Co-Authored-By: Claude Fable 5.2 --- book/src/evo-sdk/dashpay-contact-requests.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/book/src/evo-sdk/dashpay-contact-requests.md b/book/src/evo-sdk/dashpay-contact-requests.md index 85756baba52..a9b05ea8205 100644 --- a/book/src/evo-sdk/dashpay-contact-requests.md +++ b/book/src/evo-sdk/dashpay-contact-requests.md @@ -50,16 +50,18 @@ recipient's identity decryption public key. From protocol version 15 a contact request may also carry the optional `encryptedShieldedAddress`: the sender's shielded payment address for this -contact, encrypted with the same shared secret. It is exactly 64 bytes: +contact, encrypted with the same shared secret. Wallets write it in 64 bytes: - 16 bytes: AES-CBC initialization vector, drawn at random for this field - 48 bytes: AES-CBC ciphertext of the 43-byte address (an 11-byte diversifier followed by a 32-byte transmission key) -The contract accepts 64 or 80 bytes, the two lengths in its range that are an -IV plus whole blocks. Wallets write 64 and keep 80 for a later encoding. A -sender gives each contact a different address, so a payment that arrives on -one is attributed to that contact. +That is the current encoding, not the only length the contract accepts: it +takes 64 or 80 bytes, the two lengths in its range that are an IV plus whole +blocks, and wallets keep 80 for a later encoding. A reader that cannot decode +a value ignores it instead of refusing the contact request. A sender gives +each contact a different address, so a payment that arrives on one is +attributed to that contact. From protocol version 15 the DashPay contract (v3) states these checks in its schema, and a contact request that fails one is refused (and the fee charged):