From b0ead30e03db3f1f85d9e8a9f1320811b3ea7e95 Mon Sep 17 00:00:00 2001 From: Quantum Explorer Date: Thu, 12 Nov 2026 23:03:37 +0700 Subject: [PATCH] feat(contract)!: describe a multiple choice proposal by a document, a url or both (PV15) A multiple choice proposal had to point at a description document hosted on Platform. People will also host a description themselves, so the proposal now says what is being decided in one of two places, or both: a moderated document an elected team can take down, checked as before, or its `url`, which nothing on chain reads or moderates. - `descriptionId`, `descriptionContractId` and `descriptionDocumentType` are no longer required. Two `propertyConstraints` rules hold a proposal on create and on every edit: `describedByADocumentOrAUrl` (at least one of the two) and `descriptionDocumentNamedWhole` (the three properties naming a document are all given or none). - The reference on `descriptionId` is unchanged: a proposal that points at a document still needs one its host's elected team can remove. - A proposal described at a url alone is accepted and takes choices; one with neither, or with a document named in part, is refused with `DocumentPropertyConstraintViolatedError`. The contract schema changes, so the ten nullifier_batch_guard roots, the activation root and the stored contract fixture line of the decision proposals contract are recomputed. Protocol version 15 is unreleased; protocol version 14 and earlier are unchanged. Co-Authored-By: Claude Fable 5.2 --- docs/protocol/decision-proposals.md | 33 +++- .../decision-proposals-contract/README.md | 19 ++- ...decision-proposals-contract-documents.json | 40 ++++- .../decision-proposals-contract/src/lib.rs | 33 +++- .../decision-proposals-contract/src/v1/mod.rs | 33 ++-- .../unit/decisionProposalsContract.spec.js | 31 +++- .../fixtures/stored_contracts/stored.jsonl | 2 +- .../v3/mod.rs | 2 +- .../token/shielded/nullifier_batch_guard.rs | 20 +-- .../multiple_choice_proposal_tests.rs | 151 ++++++++++++++++++ .../rs-platform-version/src/version/v15.rs | 7 +- 11 files changed, 318 insertions(+), 53 deletions(-) diff --git a/docs/protocol/decision-proposals.md b/docs/protocol/decision-proposals.md index fbd2d8deb85..87967e481bf 100644 --- a/docs/protocol/decision-proposals.md +++ b/docs/protocol/decision-proposals.md @@ -152,10 +152,10 @@ rejected. | Property | Type | Meaning | | --- | --- | --- | | `title` | string, 1 to 128 characters and at most 512 bytes, required | The question, in one line | -| `descriptionId` | identifier, required | The document saying what is being decided: a [reference whose target the proposal names](../../book/src/contract-keywords/refers-to-dynamic.md) | -| `descriptionContractId` | identifier, required | The contract that document lives in: `refersTo` a `contract` with `contractRequirements: { "moderation": "elected", "ownerProtected": false }` | -| `descriptionDocumentType` | string, 1 to 64 characters, required | That document's document type | -| `url` | string, `format: uri`, 1 to 512 characters and at most 512 bytes | Where the proposal is discussed | +| `descriptionId` | identifier | The document saying what is being decided, when the proposal points at one: a [reference whose target the proposal names](../../book/src/contract-keywords/refers-to-dynamic.md) | +| `descriptionContractId` | identifier, given with `descriptionId` and only with it | The contract that document lives in: `refersTo` a `contract` with `contractRequirements: { "moderation": "elected", "ownerProtected": false }` | +| `descriptionDocumentType` | string, 1 to 64 characters, given with `descriptionId` and only with it | That document's document type | +| `url` | string, `format: uri`, 1 to 512 characters and at most 512 bytes, required when `descriptionId` is left out | Where what is being decided is described, for a proposal that points at no description document; where it is discussed, for one that does | | `open` | boolean, required | Whether anyone may enter choices. Only the proposal's owner may when it is `false` | Indexes: `byOwner` (`$ownerId`, `$createdAt`) and `byCreatedAt` (`$createdAt`), @@ -165,8 +165,26 @@ neither unique. A proposal costs its storage and nothing else, so text held in it would be cheap to fill with anything and could never be taken down: the proposal is -undeletable. It therefore holds no description. It points at a document that -does, hosted where moderators can remove it: +undeletable. It therefore holds no description. What is being decided is said +in one of two places, or both: + +- **A description document**, hosted on Platform where an elected team can + remove it. The proposal names it with `descriptionId`, + `descriptionContractId` and `descriptionDocumentType`, and it is checked as + below. +- **A url**, for a description hosted anywhere else. Nothing on chain reads or + moderates what it points at: whoever serves it can change or remove it, and + nobody else can. A proposal holds at most 512 bytes of it. + +Two `propertyConstraints` rules hold a proposal to that, on create and on +every edit (`DocumentPropertyConstraintViolatedError`): + +| Rule | Condition | Refuses | +| --- | --- | --- | +| `describedByADocumentOrAUrl` | `{ "anyOf": [{ "present": "descriptionId" }, { "present": "url" }] }` | A proposal with neither | +| `descriptionDocumentNamedWhole` | `{ "in": [{ "countPresent": ["descriptionId", "descriptionContractId", "descriptionDocumentType"] }, [0, 3]] }` | A description document named in part: an id with no contract or no type, or a contract or a type with no id | + +A proposal that points at a description document declares it this way: ```json "descriptionId": { @@ -282,6 +300,9 @@ What this does and does not give: type's `position` order, that fills the `body` slot, then `bodyBytes` (see [the binding rule](../../book/src/contract-keywords/refers-to-dynamic.md#documenttyperequirements)). - `title` and `url` are still text of the proposal. +- A proposal described at a `url` alone gets none of the above. What the url + serves is outside the chain: it can change after choices were entered, and + no moderator can take it down. A client shows it as an outside link. ### `choice` diff --git a/packages/decision-proposals-contract/README.md b/packages/decision-proposals-contract/README.md index 5df59368770..baa8c01a04a 100644 --- a/packages/decision-proposals-contract/README.md +++ b/packages/decision-proposals-contract/README.md @@ -61,9 +61,14 @@ can see the proposal as it was when a choice was entered. Whether it is `open` never changes. Creating it opens no vote and states no fund: the first choice does. -The proposal holds no description of its own. It points at a document saying -what is being decided, in another contract, so that the description can be -taken down: the document type is a moderated one (its documents leave state +The proposal holds no description of its own. What is being decided is said +in one of two places, or both: at its `url`, for a description hosted +anywhere, which nothing on chain reads or moderates; or in a document the +proposal points at, in another contract, so that the description can be +taken down. A proposal gives at least one, and names a description document +with all three of its properties or none (the `describedByADocumentOrAUrl` +and `descriptionDocumentNamedWhole` rules). For a document, the document type +is a moderated one (its documents leave state only through a moderator's recorded removal) holding a string or a byte array that the removal takes away and that the document's author writes, the contract is one whose moderators the masternodes elect and whose owner they @@ -73,10 +78,10 @@ at any time after they are written. | Property | Type | Meaning | | --- | --- | --- | | `title` | string, 1 to 128 characters and at most 512 bytes, required | The question, in one line | -| `descriptionId` | identifier, required | The document saying what is being decided | -| `descriptionContractId` | identifier, required | The contract that document lives in, one declaring elected moderation that does not protect its owner from the team | -| `descriptionDocumentType` | string, 1 to 64 characters, required | That document's document type | -| `url` | string, a URI of 1 to 512 characters and at most 512 bytes | Where the proposal is discussed | +| `descriptionId` | identifier | The document saying what is being decided, when the proposal points at one | +| `descriptionContractId` | identifier, given with `descriptionId` and only with it | The contract that document lives in, one declaring elected moderation that does not protect its owner from the team | +| `descriptionDocumentType` | string, 1 to 64 characters, given with `descriptionId` and only with it | That document's document type | +| `url` | string, a URI of 1 to 512 characters and at most 512 bytes, required when `descriptionId` is left out | Where what is being decided is described, for a proposal that points at no description document; where it is discussed, for one that does | | `open` | boolean, required | Whether anyone may enter choices. Only the proposal's owner may when it is false | Indexes: `byOwner` (`$ownerId`, `$createdAt`) lists an identity's proposals; diff --git a/packages/decision-proposals-contract/schema/v1/decision-proposals-contract-documents.json b/packages/decision-proposals-contract/schema/v1/decision-proposals-contract-documents.json index 0a95ad1f3b9..2e6e01e1535 100644 --- a/packages/decision-proposals-contract/schema/v1/decision-proposals-contract-documents.json +++ b/packages/decision-proposals-contract/schema/v1/decision-proposals-contract-documents.json @@ -321,7 +321,7 @@ } } }, - "description": "The document saying what is being decided: a document of a moderated type its contract's elected team may delete, at any time after it is written, holding text its author wrote that the removal takes away with it", + "description": "The document saying what is being decided, when the proposal points at one: a document of a moderated type its contract's elected team may delete, at any time after it is written, holding text its author wrote that the removal takes away with it. Left out, with the two properties naming where it lives, by a proposal described at its url", "position": 1 }, "descriptionContractId": { @@ -337,14 +337,14 @@ "ownerProtected": false } }, - "description": "The contract the description document lives in, one whose moderators the masternodes elect and whose owner they may moderate like anyone", + "description": "The contract the description document lives in, one whose moderators the masternodes elect and whose owner they may moderate like anyone. Given with descriptionId, and only with it", "position": 2 }, "descriptionDocumentType": { "type": "string", "minLength": 1, "maxLength": 64, - "description": "The document type of the description document", + "description": "The document type of the description document. Given with descriptionId, and only with it", "position": 3 }, "url": { @@ -353,7 +353,7 @@ "minLength": 1, "maxLength": 512, "maxBytes": 512, - "description": "Where the proposal is discussed", + "description": "Where what is being decided is described, for a proposal that points at no description document; where it is discussed, for one that does. Required when descriptionId is left out", "position": 4 }, "open": { @@ -366,9 +366,6 @@ "$createdAt", "$updatedAt", "title", - "descriptionId", - "descriptionContractId", - "descriptionDocumentType", "open" ], "immutable": [ @@ -444,8 +441,35 @@ } } ], + "propertyConstraints": { + "describedByADocumentOrAUrl": { + "anyOf": [ + { + "present": "descriptionId" + }, + { + "present": "url" + } + ] + }, + "descriptionDocumentNamedWhole": { + "in": [ + { + "countPresent": [ + "descriptionId", + "descriptionContractId", + "descriptionDocumentType" + ] + }, + [ + 0, + 3 + ] + ] + } + }, "additionalProperties": false, - "description": "A question put to the masternodes whose answers are the choices entered for it. What is being decided is said by a document the proposal points at, of a moderated type of a contract whose moderators the masternodes elect, so that they can take it down. Anyone may enter choices when it is open, and only its owner when it is not. Its title, url and the description it points at may be changed for two hours after it is created; whether it is open never changes, and it is never deleted" + "description": "A question put to the masternodes whose answers are the choices entered for it. What is being decided is said in one of two places, or both: a document the proposal points at, of a moderated type of a contract whose moderators the masternodes elect, so that they can take it down; or a url, which nothing on chain moderates. Anyone may enter choices when it is open, and only its owner when it is not. Its title, url and the description it points at may be changed for two hours after it is created; whether it is open never changes, and it is never deleted" }, "choice": { "type": "object", diff --git a/packages/decision-proposals-contract/src/lib.rs b/packages/decision-proposals-contract/src/lib.rs index f5032f6e9a6..556f73da4cc 100644 --- a/packages/decision-proposals-contract/src/lib.rs +++ b/packages/decision-proposals-contract/src/lib.rs @@ -224,9 +224,9 @@ mod tests { multiple_choice_proposal::properties::OPEN, ]) ); - // The question holds no description of its own: it points at a document of a - // moderated type, of the contract and the type it names, holding a string or bytes - // that a moderator's removal takes away and that its author writes + // The question holds no description of its own. When it points at one, it is a + // document of a moderated type, of the contract and the type it names, holding a + // string or bytes that a moderator's removal takes away and that its author writes let taken_with_the_document = serde_json::json!({ "allOf": [ { "not": { "contains": ["$moderatorAbilities.deleteKeepsFields", "$property"] } }, @@ -294,13 +294,38 @@ mod tests { .iter() .filter_map(Value::as_str) .collect(); + // A description document is one of two ways to say what is being decided, so none + // of the three properties naming it is required, and neither is the url for property in [ multiple_choice_proposal::properties::DESCRIPTION_ID, multiple_choice_proposal::properties::DESCRIPTION_CONTRACT_ID, multiple_choice_proposal::properties::DESCRIPTION_DOCUMENT_TYPE, + multiple_choice_proposal::properties::URL, ] { - assert!(required.contains(&property), "{property} is required"); + assert!(!required.contains(&property), "{property} is not required"); } + // A proposal gives one of the two or both, and names a description document whole + assert_eq!( + question["propertyConstraints"], + serde_json::json!({ + multiple_choice_proposal::rules::DESCRIBED_BY_A_DOCUMENT_OR_A_URL: { + "anyOf": [ + { "present": multiple_choice_proposal::properties::DESCRIPTION_ID }, + { "present": multiple_choice_proposal::properties::URL } + ] + }, + multiple_choice_proposal::rules::DESCRIPTION_DOCUMENT_NAMED_WHOLE: { + "in": [ + { "countPresent": [ + multiple_choice_proposal::properties::DESCRIPTION_ID, + multiple_choice_proposal::properties::DESCRIPTION_CONTRACT_ID, + multiple_choice_proposal::properties::DESCRIPTION_DOCUMENT_TYPE + ] }, + [0, 3] + ] + } + }) + ); // Every question says whether it is open, for good assert_eq!( question["properties"][multiple_choice_proposal::properties::OPEN]["type"], diff --git a/packages/decision-proposals-contract/src/v1/mod.rs b/packages/decision-proposals-contract/src/v1/mod.rs index ed0f96862b7..d1eb2f66457 100644 --- a/packages/decision-proposals-contract/src/v1/mod.rs +++ b/packages/decision-proposals-contract/src/v1/mod.rs @@ -34,27 +34,42 @@ pub mod document_types { /// A question put to the masternodes whose answers are the choices entered for it. Any /// identity may enter [`choice`]s when it is open, and only its owner when it is not; whoever - /// may enter them may enter several. What is being decided is not text of the proposal: - /// the proposal points at a document saying it, of a moderated document type of a contract - /// whose moderators the masternodes elect, so that a description can be taken down. Its + /// may enter them may enter several. What is being decided is not text of the proposal. + /// It is said in one of two places, or both: a document the proposal points at, of a + /// moderated document type of a contract whose moderators the masternodes elect, so that + /// a description can be taken down; or a url, which nothing on chain moderates. Its /// owner may edit the title and url, and point it at another description, for two hours /// after creating it, and every version is kept; whether it is open never changes. /// Undeletable. pub mod multiple_choice_proposal { pub const NAME: &str = "multipleChoiceProposal"; + pub mod rules { + /// The `propertyConstraints` rule holding a proposal to a description: the + /// document it points at, its url, or both. + pub const DESCRIBED_BY_A_DOCUMENT_OR_A_URL: &str = "describedByADocumentOrAUrl"; + /// The `propertyConstraints` rule holding the three properties that name a + /// description document together: all given, or none. + pub const DESCRIPTION_DOCUMENT_NAMED_WHOLE: &str = "descriptionDocumentNamedWhole"; + } + pub mod properties { pub const TITLE: &str = "title"; - /// The id of the document saying what is being decided. Its document type is a - /// moderated one holding a string or a byte array that a moderator's removal - /// takes away and that its author writes, which its contract's elected team may - /// delete from at any time. + /// The id of the document saying what is being decided, when the proposal points + /// at one. Its document type is a moderated one holding a string or a byte array + /// that a moderator's removal takes away and that its author writes, which its + /// contract's elected team may delete from at any time. pub const DESCRIPTION_ID: &str = "descriptionId"; /// The id of the contract the description document lives in, one declaring - /// elected moderation that does not protect its owner from the team. + /// elected moderation that does not protect its owner from the team. Given with + /// the description's id, and only with it. pub const DESCRIPTION_CONTRACT_ID: &str = "descriptionContractId"; - /// The name of the description document's document type. + /// The name of the description document's document type. Given with the + /// description's id, and only with it. pub const DESCRIPTION_DOCUMENT_TYPE: &str = "descriptionDocumentType"; + /// Where what is being decided is described, for a proposal that points at no + /// description document, which must then give it; where it is discussed, for one + /// that does. pub const URL: &str = "url"; /// Whether anyone may enter choices. Only the proposal's owner may when it is /// false. diff --git a/packages/decision-proposals-contract/test/unit/decisionProposalsContract.spec.js b/packages/decision-proposals-contract/test/unit/decisionProposalsContract.spec.js index 639c6172f2c..8b5cb467397 100644 --- a/packages/decision-proposals-contract/test/unit/decisionProposalsContract.spec.js +++ b/packages/decision-proposals-contract/test/unit/decisionProposalsContract.spec.js @@ -250,13 +250,39 @@ describe('Decision Proposals Contract', () => { expect(validateType('multipleChoiceProposal', await rawQuestion()).isValid()).to.be.true(); }); - it('should not need a url', async () => { + it('should not need a url when it points at a description document', async () => { const raw = await rawQuestion(); delete raw.url; expect(validateType('multipleChoiceProposal', raw).isValid()).to.be.true(); }); + it('should not need a description document when it gives a url', async () => { + const raw = await rawQuestion(); + delete raw.descriptionId; + delete raw.descriptionContractId; + delete raw.descriptionDocumentType; + + expect(validateType('multipleChoiceProposal', raw).isValid()).to.be.true(); + }); + + it('should be described by a document, a url or both, the document named whole', () => { + // Judged when a proposal is written, not by the JSON Schema of its type + const { propertyConstraints } = decisionProposalsContractDocumentsSchema.multipleChoiceProposal; + + expect(propertyConstraints).to.deep.equal({ + describedByADocumentOrAUrl: { + anyOf: [{ present: 'descriptionId' }, { present: 'url' }], + }, + descriptionDocumentNamedWhole: { + in: [ + { countPresent: ['descriptionId', 'descriptionContractId', 'descriptionDocumentType'] }, + [0, 3], + ], + }, + }); + }); + it('should keep its text and its description editable for two hours, every version, and never be deleted', () => { const { multipleChoiceProposal } = decisionProposalsContractDocumentsSchema; @@ -368,9 +394,6 @@ describe('Decision Proposals Contract', () => { [ 'title', - 'descriptionId', - 'descriptionContractId', - 'descriptionDocumentType', 'open', ].forEach((property) => { it(`should require ${property}`, async () => { diff --git a/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl b/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl index bca76fdb3f4..44412434d26 100644 --- a/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl +++ b/packages/rs-dpp/tests/fixtures/stored_contracts/stored.jsonl @@ -8,7 +8,7 @@ {"contract":"system DocumentHistory","sha256":"60a6904648adf2f98aa4a806e6279112fc5460f47bf529c916b0ef2dbf083cfd","indexStructures":"9f16f37fbeb19d500ad6b3ec489e45d2d3fcea730b99baf57b3e397b96fd2dd3","bytes":"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"} {"contract":"system AppConnect","sha256":"4d6dd642c6f74fe2fcfd04696bd8d58b8ca418586619301b235fe7729f73c09a","indexStructures":"05f449543911990d081569c8124f9fbb312a5d3dcbbe045d6f7dfb0a14dd8da4","bytes":"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"} {"contract":"system ModerationCharters","sha256":"08e879d58b351ca5dbb3beb72f0c2905679a24233c4aef7682a5cf4d7bae24cb","indexStructures":"959daf512c8055ab2f16c63e84b5ca8cbf1fba87c461bbc30279be340c74ad35","bytes":"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"} -{"contract":"system DecisionProposals","sha256":"a12c600de9a6a2b249c967c408207f82ae95df41e1900a1fd40a9a8ffbda03fd","indexStructures":"0b3ce0e20cde7b45a89351adea5ee84da634ab0b36268c00891c7917a5969bc8","bytes":"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"} +{"contract":"system DecisionProposals","sha256":"ad1fd3ed595e76cb6cbb2f4c0d6493bf9c9d66d2a7f4f84c2d5742089fd7a895","indexStructures":"0b3ce0e20cde7b45a89351adea5ee84da634ab0b36268c00891c7917a5969bc8","bytes":"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"} {"contract":"system TokenMarket","sha256":"a76774b65159a4ff93874a556e72cd29a7d7d3aa35fcd972e76e3b2e85cf2d0e","indexStructures":"8ff1e8772d7b8e32e036dc6ef3324be80c0bd02177c35fac5f18419a6926d279","bytes":"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"} {"contract":"mainnet 2NZwXdb3wGQzbWQeQZHFAaL4GuQzuzF2v8iQfcKuUC5q","sha256":"f88948650030b46642a88f5bbe753b611fea8bc426736536ed92fcc34f046775","indexStructures":"4fe79ced8e35b61d7ebb7b90bd5e022c8ce761fd5f1ad500616b65d7ead95eb0","bytes":"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"} {"contract":"mainnet 2UDyunHraJLbg1TqjYBHhVoaCetPKcy5aAVdGYxmWZga","sha256":"a3353b8902cb43493e3f2748ee49e9d30b41039ca87e7ef65c82b5b9cf7bcada","indexStructures":"74eaa293ce4381e8af811c0b929a7993cbe2ef218f2f7f9452e0f3dbf0d4ed03","bytes":"AhXVC/KBoXOMVjfhmUg5RJO8HV2kSxbGS8a+p1IpXs9fAAAAAAABAQAAASj+fLksRsQidDbOM1gGlYam9hkWlYmgY835HLI6FUqTAAEEbm90ZRYEEgR0eXBlEgZvYmplY3QSCnByb3BlcnRpZXMWARIHbWVzc2FnZRYDEgR0eXBlEgZzdHJpbmcSCW1heExlbmd0aAN+Eghwb3NpdGlvbgMAEgdpbmRpY2VzFQEWAxIEbmFtZRIHbWVzc2FnZRIKcHJvcGVydGllcxUBFgESB21lc3NhZ2USA2FzYxIGdW5pcXVlEwASFGFkZGl0aW9uYWxQcm9wZXJ0aWVzEwAAAAAAAAAAAAAAAQRub3RlAAEHbWVzc2FnZQsAAT8AAAAAAAAAAAEHbWVzc2FnZQsAAT8AAAAAAAAAAAEHbWVzc2FnZQdtZXNzYWdlAQdtZXNzYWdlAQABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIALQABAAIAAAEBAQdtZXNzYWdlAAEABQAAAAABAAE/AAAAAAEAAAAAAAAAAAAAAA=="} 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 2817fb11f69..032e8b767b2 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), - "4d8f2a9f55e6fdeb24307bea0c7faadcfa91baa93e0b5e72bd03865ed1803c69", + "16f1b856bfe6f2e932b6ff98df25a193d173c756ab5add58920796b0f1c5ad81", "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/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 6916e42eb49..abb23d1b912 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() ), - "3af8b4d7945db95a0a5acbc5777278dc9d54b92247b2fa5381ce17525bf63ec2" + "98f6fdff13504a6572b8907f1467fa1592ad1b217980d7e7402c6ca089d609ba" ); 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", - "2e364d1f94204d0e69a5deb1c151aae69bd8e8b0c6bfa2887aa3590eb778f9a3", + "1b6e3a1b8df56f4193d7800d667abff4d70f31f3ae9b02402084fc800892cc97", ), "valid-payment" => ( "9388d5cf63c4a571b9fb009679e2e34d0b681acc88f0f5195e7287c7efbd92f7", - "44dfbad3721901f165edbce5ea92c91a22d9b1e125cc801a52d4938bd01d3454", + "a49c87157d246e45793444b3034fca911b82a7a88022449eeff98f913db0e5ce", ), "failed-payment" => ( "d9b5fe191841bea952494f2a45e3833f925f4d367a1937b2ef1235a1aa01f51e", - "afa7559900bbecf9840d19cd4e9af013d887ab642fdfa37db7d7d4f75618aaed", + "8896913b4a31f3a1a0a1a8d8b244d0a2bd06f06d2ff195bd9e321ec4c11c7732", ), "within-bundle-repeat" => ( "8023e03a697a20f6a78396a05503a4bc583ca8f69e19bd7ee07a6ae0ce7be478", - "045f516d45879d472b62a23eb1d8675d5d79777ac1f07af0712328292b9ae5aa", + "b94f198111e0740d34ec26cfb3372d0dfd5d026fcd7edb898ec0f361c196e17a", ), "stored-repeat" => ( "05652ac85c972902e8c09d20a7d8586e17e9434a478b335da136ad85f73def01", - "b2d0b86d502164041844eb4ecfff816b4970dc1d0725df15a2117384541404a8", + "69d7967cf417e2d23170f62ba97a79c6adafb61272e12b542c12fc65b17350ac", ), "open-mint-group" => ( "5c68381297c9bf68c5e85ebe6bb9e0f1289e2c07718eecfb5e6773d6009455bb", - "c9629605b64e1ee61ce490738253f604fea7794ad99a76f362ab9360cd4bbaf5", + "55f671d4fc4ad41257f0121056600835a8f02f1ea2a5b75887ba55234d2d6e9c", ), "closing-mint-group" => ( "2cedc16732c76e0605b5f46085db3d69c12936a5af55a2a82f52ec9e9ca67e38", - "39a37c39aef7699d72c2ac669c3bb177500fe7667f3bc13d61e010c6de52578b", + "574f8f93d9bfc0f19b405f477a563313f8a09762f039e3eca4f3c855811d69b3", ), "open-burn-group" => ( "e664a045f020ff84de1ca98f364fbabccfc141ad46aa82c79491a340bb0db5f8", - "3e6f0e1f5e8eec10b71dda07ca3c72b8dae61aa898fda7dbad9053319cbfbd32", + "6afde33de59fa0e2086a5d12b160b299bdcd7b7ae4436e10a4028c7215d05f0f", ), "closing-burn-group" => ( "93e1732286f168c4a91d2765931e181c5721bfca1bfd5f93b8baacca03e00b2b", - "94ac1e01e41b10927a1fc6e3e9e3334ec41b89dd32fd3a37cbdae14fa5a78590", + "7a705fc665401c0eb25650b01932425d2f92c36e974c1e9458c072dc4baa6c46", ), _ => unreachable!("enumerated characterization case"), }; diff --git a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/multiple_choice_proposal_tests.rs b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/multiple_choice_proposal_tests.rs index 6f9aa110f34..2bc15f40db9 100644 --- a/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/multiple_choice_proposal_tests.rs +++ b/packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/masternode_vote/multiple_choice_proposal_tests.rs @@ -2191,3 +2191,154 @@ async fn should_take_the_description_from_a_moderated_text_of_an_elected_contrac "{error:?}" ); } + +/// What is being decided is said by a description document, at a url, or both: people +/// either write it on Platform, where an elected team can take it down, or host it +/// themselves. A proposal gives at least one, and names a description document whole. +#[tokio::test] +async fn should_take_the_description_from_a_document_a_url_or_both() { + let (mut platform, platform_version, contract, mut rng) = setup(); + let mut proposer = writer(&mut platform, &mut rng); + let mut alice = writer(&mut platform, &mut rng); + let host = description_host(true, platform_version); + let description_id = describe( + &platform, + &host, + &mut proposer, + TEXT, + 10_000, + &mut rng, + platform_version, + ) + .await; + let url = || { + ( + multiple_choice_proposal::properties::URL.to_string(), + Value::Text("https://example.org/proposals/mascot".to_string()), + ) + }; + let pointing_at_the_document = + || question_properties("Which mascot?", true, host.id(), TEXT, description_id); + let without = |mut properties: BTreeMap, left_out: &[&str]| { + for property in left_out { + properties.remove(*property); + } + properties + }; + let description_document = [ + multiple_choice_proposal::properties::DESCRIPTION_ID, + multiple_choice_proposal::properties::DESCRIPTION_CONTRACT_ID, + multiple_choice_proposal::properties::DESCRIPTION_DOCUMENT_TYPE, + ]; + + // A url alone: the description is hosted elsewhere, and nothing on chain is checked + let mut at_a_url = without(pointing_at_the_document(), &description_document); + at_a_url.extend([url()]); + let (transition, url_only_id) = create_transition( + &contract, + &mut proposer, + multiple_choice_proposal::NAME, + at_a_url, + &mut rng, + platform_version, + ) + .await; + process_valid(&platform, transition, 20_000, platform_version); + let stored = stored_document( + &platform, + &contract, + multiple_choice_proposal::NAME, + url_only_id, + ) + .expect("expected the proposal described at a url"); + for property in description_document { + assert!(stored.get(property).is_none(), "{property}"); + } + // and it takes choices like any other + enter( + &platform, + &contract, + &mut alice, + url_only_id, + "An owl", + 30_000, + &mut rng, + platform_version, + ) + .await; + + // Both: the document is checked as ever, the url is where it is discussed + let mut both = pointing_at_the_document(); + both.extend([url()]); + let (transition, _) = create_transition( + &contract, + &mut proposer, + multiple_choice_proposal::NAME, + both, + &mut rng, + platform_version, + ) + .await; + process_valid(&platform, transition, 20_000, platform_version); + + // Neither: a proposal says what is being decided somewhere + let refused_by = |error: ConsensusError, rule: &str| match &error { + ConsensusError::BasicError(BasicError::DocumentPropertyConstraintViolatedError(e)) => { + assert_eq!(e.constraint(), rule); + } + other => panic!("expected the rule {rule} to refuse it, got {other:?}"), + }; + let (transition, _) = create_transition( + &contract, + &mut proposer, + multiple_choice_proposal::NAME, + without(pointing_at_the_document(), &description_document), + &mut rng, + platform_version, + ) + .await; + refused_by( + process_refused(&platform, transition, 20_000, platform_version), + multiple_choice_proposal::rules::DESCRIBED_BY_A_DOCUMENT_OR_A_URL, + ); + + // A description document named in part, with a url or without: its id with no contract + // or no type, and a contract and a type with no id + for left_out in [ + vec![multiple_choice_proposal::properties::DESCRIPTION_CONTRACT_ID], + vec![multiple_choice_proposal::properties::DESCRIPTION_DOCUMENT_TYPE], + vec![multiple_choice_proposal::properties::DESCRIPTION_ID], + vec![ + multiple_choice_proposal::properties::DESCRIPTION_CONTRACT_ID, + multiple_choice_proposal::properties::DESCRIPTION_DOCUMENT_TYPE, + ], + ] { + for with_a_url in [false, true] { + let mut properties = without(pointing_at_the_document(), &left_out); + if with_a_url { + properties.extend([url()]); + } + // With no id and no url, the first rule refuses it before this one is judged + let rule = if !with_a_url + && left_out.contains(&multiple_choice_proposal::properties::DESCRIPTION_ID) + { + multiple_choice_proposal::rules::DESCRIBED_BY_A_DOCUMENT_OR_A_URL + } else { + multiple_choice_proposal::rules::DESCRIPTION_DOCUMENT_NAMED_WHOLE + }; + let (transition, _) = create_transition( + &contract, + &mut proposer, + multiple_choice_proposal::NAME, + properties, + &mut rng, + platform_version, + ) + .await; + refused_by( + process_refused(&platform, transition, 20_000, platform_version), + rule, + ); + } + } +} diff --git a/packages/rs-platform-version/src/version/v15.rs b/packages/rs-platform-version/src/version/v15.rs index da336b11034..5c06c99bda6 100644 --- a/packages/rs-platform-version/src/version/v15.rs +++ b/packages/rs-platform-version/src/version/v15.rs @@ -756,9 +756,10 @@ pub const PROTOCOL_VERSION_15: ProtocolVersion = 15; /// the declared kind (40122, 40143, 40144), and the document exists (40120) or, for a /// moderated one a replace keeps, was removed on the record. A replace checks the /// reference again when its value or a property it reads the target from changed. -/// The decision proposals contract's `multipleChoiceProposal` type uses it for its -/// description: a moderated document, of a contract declaring elected moderation, whose -/// text a moderator's removal takes away. Protocol v14 and earlier keep +/// The decision proposals contract's `multipleChoiceProposal` type uses it for a +/// description hosted on Platform: a moderated document, of a contract declaring elected +/// moderation, whose text a moderator's removal takes away (a proposal may give a url +/// instead, or both). Protocol v14 and earlier keep /// `apply_property_reference` 0, which does not read the keys, and /// `document_reference_validation` 0, which no dynamic reference reaches. /// Version 1 takes this reading only for a declaration version 0 cannot read at all (a