diff --git a/book/src/evo-sdk/dashpay-contact-requests.md b/book/src/evo-sdk/dashpay-contact-requests.md index 8add70f5f37..a9b05ea8205 100644 --- a/book/src/evo-sdk/dashpay-contact-requests.md +++ b/book/src/evo-sdk/dashpay-contact-requests.md @@ -48,6 +48,21 @@ 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. 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) + +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): @@ -55,7 +70,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..0d26b13df6d 100644 --- a/packages/dashpay-contract/src/v3/mod.rs +++ b/packages/dashpay-contract/src/v3/mod.rs @@ -19,6 +19,15 @@ 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 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: // // - `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-dpp/tests/fixtures/stored_contracts/stored.jsonl b/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl index 44412434d26..7ea1e4380ea 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":"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"} -{"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":"AqGTp5ko4dtlMpwckpY0ctU4mmoPT0ISnF6S2GiMXarXAgAAAAABAQAAAQABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxBjb250cmFjdEtleXdvcmRzFgkSBHR5cGUSBm9iamVjdBIQZG9jdW1lbnRzTXV0YWJsZRMAEgxjYW5CZURlbGV0ZWQTABIXY3JlYXRpb25SZXN0cmljdGlvbk1vZGUCAhIHaW5kaWNlcxUCFgISBG5hbWUSCWJ5S2V5d29yZBIKcHJvcGVydGllcxUBFgESB2tleXdvcmQSA2FzYxYCEgRuYW1lEgxieUNvbnRyYWN0SWQSCnByb3BlcnRpZXMVARYBEgpjb250cmFjdElkEgNhc2MSCnByb3BlcnRpZXMWAhIHa2V5d29yZBYEEgR0eXBlEgZzdHJpbmcSCW1pbkxlbmd0aAIDEgltYXhMZW5ndGgCMhIIcG9zaXRpb24CABIKY29udHJhY3RJZBYGEgR0eXBlEgVhcnJheRIJYnl0ZUFycmF5EwESCG1pbkl0ZW1zAiASCG1heEl0ZW1zAiASCHBvc2l0aW9uAgESEGNvbnRlbnRNZWRpYVR5cGUSIWFwcGxpY2F0aW9uL3guZGFzaC5kcHAuaWRlbnRpZmllchIIcmVxdWlyZWQVAhIKY29udHJhY3RJZBIHa2V5d29yZBILZGVzY3JpcHRpb24S+wElS2V5d29yZHMgYXNzb2NpYXRlZCB3aXRoIHRoZSBjb250cmFjdCBhbGxvd2luZyBmb3IgYmV0dGVyIHNlYXJjaGFiaWxpdHkuIFRoaXMgZG9jdW1lbnQgdHlwZSBjYW4gYmUgZGVsZXRlZCBidXQgbm90IG1hbnVhbGx5IGNyZWF0ZWQgbm9yIHVwZGF0ZWQuIENyZWF0aW9uIG9jY3VycyBhdXRvbWF0aWNhbGx5IGludGVybmFsbHkgb24gRGF0YUNvbnRyYWN0Q3JlYXRlIGFuZCBtaXJyb3JzIHRoZSBjb250cmFjdCdzIGtleXdvcmRzIGZpZWxkLiBJdCBjYW4gYmUgdXBkYXRlZCB3aXRoIERhdGFDb250cmFjdFVwZGF0ZS4SFGFkZGl0aW9uYWxQcm9wZXJ0aWVzEwAPZnVsbERlc2NyaXB0aW9uFgkSBHR5cGUSBm9iamVjdBIQZG9jdW1lbnRzTXV0YWJsZRMBEgxjYW5CZURlbGV0ZWQTABIXY3JlYXRpb25SZXN0cmljdGlvbk1vZGUCAhIHaW5kaWNlcxUBFgMSBG5hbWUSDGJ5Q29udHJhY3RJZBIKcHJvcGVydGllcxUBFgESCmNvbnRyYWN0SWQSA2FzYxIGdW5pcXVlEwESCnByb3BlcnRpZXMWAhIKY29udHJhY3RJZBYGEgR0eXBlEgVhcnJheRIJYnl0ZUFycmF5EwESCG1pbkl0ZW1zAiASCG1heEl0ZW1zAiASCHBvc2l0aW9uAgASEGNvbnRlbnRNZWRpYVR5cGUSIWFwcGxpY2F0aW9uL3guZGFzaC5kcHAuaWRlbnRpZmllchILZGVzY3JpcHRpb24WBBIEdHlwZRIGc3RyaW5nEgltaW5MZW5ndGgCAxIJbWF4TGVuZ3RoAvsnEBIIcG9zaXRpb24CARIIcmVxdWlyZWQVAhIKY29udHJhY3RJZBILZGVzY3JpcHRpb24SC2Rlc2NyaXB0aW9uEtNGdWxsIGRlc2NyaXB0aW9uIG9mIHRoZSBjb250cmFjdC4gVGhpcyBkb2N1bWVudCB0eXBlIGlzIG11dGFibGUgYnV0IGNyZWF0aW9uIGlzIG5vdCBhbGxvd2VkLiBDcmVhdGlvbiBvY2N1cnMgYXV0b21hdGljYWxseSBpbnRlcm5hbGx5IG9uIERhdGFDb250cmFjdENyZWF0ZSBhbmQgbWlycm9ycyB0aGUgY29udHJhY3QncyBkZXNjcmlwdGlvbiBmaWVsZCBpbml0aWFsbHkuEhRhZGRpdGlvbmFsUHJvcGVydGllcxMAEHNob3J0RGVzY3JpcHRpb24WCRIEdHlwZRIGb2JqZWN0EhBkb2N1bWVudHNNdXRhYmxlEwESDGNhbkJlRGVsZXRlZBMAEhdjcmVhdGlvblJlc3RyaWN0aW9uTW9kZQICEgdpbmRpY2VzFQEWAxIEbmFtZRIMYnlDb250cmFjdElkEgpwcm9wZXJ0aWVzFQEWARIKY29udHJhY3RJZBIDYXNjEgZ1bmlxdWUTARIKcHJvcGVydGllcxYCEgpjb250cmFjdElkFgYSBHR5cGUSBWFycmF5EglieXRlQXJyYXkTARIIbWluSXRlbXMCIBIIbWF4SXRlbXMCIBIIcG9zaXRpb24CABIQY29udGVudE1lZGlhVHlwZRIhYXBwbGljYXRpb24veC5kYXNoLmRwcC5pZGVudGlmaWVyEgtkZXNjcmlwdGlvbhYEEgR0eXBlEgZzdHJpbmcSCW1pbkxlbmd0aAIDEgltYXhMZW5ndGgCZBIIcG9zaXRpb24CARIIcmVxdWlyZWQVAhIKY29udHJhY3RJZBILZGVzY3JpcHRpb24SC2Rlc2NyaXB0aW9uEtRTaG9ydCBkZXNjcmlwdGlvbiBvZiB0aGUgY29udHJhY3QuIFRoaXMgZG9jdW1lbnQgdHlwZSBpcyBtdXRhYmxlIGJ1dCBjcmVhdGlvbiBpcyBub3QgYWxsb3dlZC4gQ3JlYXRpb24gb2NjdXJzIGF1dG9tYXRpY2FsbHkgaW50ZXJuYWxseSBvbiBEYXRhQ29udHJhY3RDcmVhdGUgYW5kIG1pcnJvcnMgdGhlIGNvbnRyYWN0J3MgZGVzY3JpcHRpb24gZmllbGQgaW5pdGlhbGx5LhIUYWRkaXRpb25hbFByb3BlcnRpZXMTAAAAAAAAAAAAAAADEGNvbnRyYWN0S2V5d29yZHMAAgdrZXl3b3JkCwEDATIAAQAAAAAAAApjb250cmFjdElkDQEAAAAAAAACB2tleXdvcmQLAQMBMgABAAAAAAAACmNvbnRyYWN0SWQNAQAAAAAAAAIMYnlDb250cmFjdElkDGJ5Q29udHJhY3RJZAEKY29udHJhY3RJZAEAAQAAAAAAAAAAAAAAAAAAAAAAAAAACWJ5S2V5d29yZAlieUtleXdvcmQBB2tleXdvcmQBAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAABCmNvbnRyYWN0SWQAAgpjb250cmFjdElkB2tleXdvcmQAAAAAAAAAAAAAAAAAAAIAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBgAAEAAgAAAQECB2tleXdvcmQAAQAFAAAAAAEBAwEyAAAAAApjb250cmFjdElkAAEAAwAAAAEAAAEgASAAAQAAAAEAAQIKY29udHJhY3RJZAdrZXl3b3JkAAAAAAAAAAAAD2Z1bGxEZXNjcmlwdGlvbgACCmNvbnRyYWN0SWQNAQAAAAAAAAtkZXNjcmlwdGlvbgsBAwH7JxAAAQAAAAAAAAIKY29udHJhY3RJZA0BAAAAAAAAC2Rlc2NyaXB0aW9uCwEDAfsnEAABAAAAAAAAAQxieUNvbnRyYWN0SWQMYnlDb250cmFjdElkAQpjb250cmFjdElkAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQpjb250cmFjdElkAAIKY29udHJhY3RJZAtkZXNjcmlwdGlvbgAAAAAAAAAAAAEAAAAAAgAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAGoAAQACAAABAQIKY29udHJhY3RJZAABAAMAAAABAAABIAEgAAEAAAALZGVzY3JpcHRpb24AAQAFAAAAAAEBAwH7JxAAAAAAAQABAgpjb250cmFjdElkC2Rlc2NyaXB0aW9uAAAAAAAAAAAAEHNob3J0RGVzY3JpcHRpb24AAgpjb250cmFjdElkDQEAAAAAAAALZGVzY3JpcHRpb24LAQMBZAABAAAAAAAAAgpjb250cmFjdElkDQEAAAAAAAALZGVzY3JpcHRpb24LAQMBZAABAAAAAAAAAQxieUNvbnRyYWN0SWQMYnlDb250cmFjdElkAQpjb250cmFjdElkAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQpjb250cmFjdElkAAIKY29udHJhY3RJZAtkZXNjcmlwdGlvbgAAAAAAAAAAAAEAAAAAAgAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAGgAAQACAAABAQIKY29udHJhY3RJZAABAAMAAAABAAABIAEgAAEAAAALZGVzY3JpcHRpb24AAQAFAAAAAAEBAwFkAAAAAAEAAQIKY29udHJhY3RJZAtkZXNjcmlwdGlvbgAAAAAAAAAAAA=="} 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 1cb30df5f2b..17b31c0c2ab 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 @@ -2712,8 +2712,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 032e8b767b2..35e83fe7629 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), - "16f1b856bfe6f2e932b6ff98df25a193d173c756ab5add58920796b0f1c5ad81", + "e5d0618fe04440f521c7ae1f7e4f7ae1eabe62a12211538208faa5d4431f7404", "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 abb23d1b912..c57557938a4 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() ), - "98f6fdff13504a6572b8907f1467fa1592ad1b217980d7e7402c6ca089d609ba" + "9401d37544da815c64abeff4aba2c939cddf246f6e56af99e220b78c98514e46" ); 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", - "1b6e3a1b8df56f4193d7800d667abff4d70f31f3ae9b02402084fc800892cc97", + "6eec6da9023f5143a81f4ee42f3549b31ea8d7f035cf664b5ec429cc5da4d81a", ), "valid-payment" => ( "9388d5cf63c4a571b9fb009679e2e34d0b681acc88f0f5195e7287c7efbd92f7", - "a49c87157d246e45793444b3034fca911b82a7a88022449eeff98f913db0e5ce", + "0c3d3f5692aa6b658389d5b6c477f081dba505f350f65f8c3ee1f28dde3a68f2", ), "failed-payment" => ( "d9b5fe191841bea952494f2a45e3833f925f4d367a1937b2ef1235a1aa01f51e", - "8896913b4a31f3a1a0a1a8d8b244d0a2bd06f06d2ff195bd9e321ec4c11c7732", + "53c5a1d1399e154096559ec2a9a3ba560db72f08c1f6b0cd316e87131af5d657", ), "within-bundle-repeat" => ( "8023e03a697a20f6a78396a05503a4bc583ca8f69e19bd7ee07a6ae0ce7be478", - "b94f198111e0740d34ec26cfb3372d0dfd5d026fcd7edb898ec0f361c196e17a", + "5766cf0e494a1cae19e034a4336196c62184c699a646d71f0de5e382b6b61fc1", ), "stored-repeat" => ( "05652ac85c972902e8c09d20a7d8586e17e9434a478b335da136ad85f73def01", - "69d7967cf417e2d23170f62ba97a79c6adafb61272e12b542c12fc65b17350ac", + "653f494271acdedb71dc0b9e7a224cc47c84e188a6c5aeb315ff7da2f66627ec", ), "open-mint-group" => ( "5c68381297c9bf68c5e85ebe6bb9e0f1289e2c07718eecfb5e6773d6009455bb", - "55f671d4fc4ad41257f0121056600835a8f02f1ea2a5b75887ba55234d2d6e9c", + "c4f5e4054bfa4e85548d713765c6da605f38559e871a2824c38bc8209f3b5a17", ), "closing-mint-group" => ( "2cedc16732c76e0605b5f46085db3d69c12936a5af55a2a82f52ec9e9ca67e38", - "574f8f93d9bfc0f19b405f477a563313f8a09762f039e3eca4f3c855811d69b3", + "16e25a2c4139c7b5294599a63461d1ecbba5109fcbf16e61a3578fb152ea72b2", ), "open-burn-group" => ( "e664a045f020ff84de1ca98f364fbabccfc141ad46aa82c79491a340bb0db5f8", - "6afde33de59fa0e2086a5d12b160b299bdcd7b7ae4436e10a4028c7215d05f0f", + "f49e470f2f1b5a9ca68245783952dac60d26d7b8b89c20766cc1a3ba43c5e0f5", ), "closing-burn-group" => ( "93e1732286f168c4a91d2765931e181c5721bfca1bfd5f93b8baacca03e00b2b", - "7a705fc665401c0eb25650b01932425d2f92c36e974c1e9458c072dc4baa6c46", + "3d5beeb201a0a33daacce4469c0a4aec845a82e6b74d31678dfe6aec24481830", ), _ => 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!( diff --git a/packages/rs-platform-version/src/version/v15.rs b/packages/rs-platform-version/src/version/v15.rs index 5c06c99bda6..af1509c1045 100644 --- a/packages/rs-platform-version/src/version/v15.rs +++ b/packages/rs-platform-version/src/version/v15.rs @@ -554,6 +554,14 @@ 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`. +/// 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