@dashevo/wasm-dpp2 4.2.0-beta.4 → 4.2.0-beta.7

package/dist/raw/wasm_dpp2.js

@@ -2537,6 +2537,15 @@ export class ConsensusError {
         const ret = wasm.consensuserror_document_encryption_error_code(this.__wbg_ptr);
         return ret === 0 ? undefined : ret;
     }
+    /**
+     * The generatedFrom error this is, or `undefined` when it is not code
+     * 10424.
+     * @returns {DocumentGeneratedFromErrorCode | undefined}
+     */
+    get documentGeneratedFromErrorCode() {
+        const ret = wasm.consensuserror_document_generated_from_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
     /**
      * The immutable-property error this is, or `undefined` when it is not
      * code 40128.
@@ -2565,7 +2574,7 @@ export class ConsensusError {
     }
     /**
      * The reference-validation error this is, or `undefined` when it is
-     * not one of codes 40120-40125, 40131, 40135 and 40136.
+     * not one of codes 40120-40125, 40131, 40135-40138, 40142 and 10423.
      * @returns {DocumentReferenceErrorCode | undefined}
      */
     get documentReferenceErrorCode() {
@@ -3478,7 +3487,8 @@ export class ContractUserModeration {
         wasm.__wbg_contractusermoderation_free(ptr, 0);
     }
     /**
-     * The action's name: ban, unban, suspend, unsuspend, warn, clearWarnings, deleteDocument or restoreDocument
+     * The action's name: ban, unban, suspend, unsuspend, warn, clearWarnings, deleteDocument,
+     * restoreDocument or changeDocumentFields
      * @returns {string}
      */
     get action() {
@@ -3527,7 +3537,8 @@ export class ContractUserModeration {
         return v1;
     }
     /**
-     * For a deleteDocument, the document it deletes
+     * For a deleteDocument, the document it deletes, and for a changeDocumentFields, the
+     * document it changes
      * @returns {Identifier | undefined}
      */
     get documentId() {
@@ -3535,7 +3546,8 @@ export class ContractUserModeration {
         return ret === 0 ? undefined : Identifier.__wrap(ret);
     }
     /**
-     * For a deleteDocument or a restoreDocument, the document type of its document
+     * For a deleteDocument, a restoreDocument or a changeDocumentFields, the document type of
+     * its document
      * @returns {string | undefined}
      */
     get documentTypeName() {
@@ -3547,6 +3559,19 @@ export class ContractUserModeration {
         }
         return v1;
     }
+    /**
+     * For a changeDocumentFields, the fields it sets, in the forms the constructor takes back:
+     * integers as bigints, identifiers and bytes as Uint8Arrays, and `null` for a field it
+     * removes
+     * @returns {Record<string, unknown> | undefined}
+     */
+    get fields() {
+        const ret = wasm.contractusermoderation_fields(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {string} base64
      * @returns {ContractUserModeration}
@@ -3628,8 +3653,9 @@ export class ContractUserModeration {
         return BigInt.asUintN(64, ret);
     }
     /**
-     * The identity the action targets, undefined for a deleteDocument and a restoreDocument:
-     * they name a document, and whose it is is only known once the document is read
+     * The identity the action targets, undefined for a deleteDocument, a restoreDocument and a
+     * changeDocumentFields: they name a document, and whose it is is only known once the
+     * document is read
      * @returns {Identifier | undefined}
      */
     get identityId() {
@@ -3644,7 +3670,7 @@ export class ContractUserModeration {
         return Identifier.__wrap(ret);
     }
     /**
-     * For a ban, a suspend, a warn and a deleteDocument, why
+     * For a ban, a suspend, a warn, a deleteDocument and a changeDocumentFields, why
      * @returns {ContractModerationReason | undefined}
      */
     get reason() {
@@ -4045,6 +4071,34 @@ export class DataContract {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_datacontract_free(ptr, 0);
     }
+    /**
+     * The first `propertyConstraints` rule `document` breaks, in name order,
+     * evaluated with the same code consensus runs on a create or replace: its
+     * properties, its owner for `$ownerId`, and for the system times the
+     * device clock in place of the block time the write will record (the
+     * document's stored creation and transfer times when it has them). A
+     * rule reading a block height the write records is not judged, since the
+     * height is unknown until the block, and neither is a rule reading a
+     * `countOf` or `sumOf` total, which only the platform reads from state
+     * (a rule's `readsTotals` lists them).
+     * `undefined` when it meets every rule of its document type.
+     *
+     * A pre-check, so an app can refuse a document before paying for a
+     * transition consensus would refuse with
+     * `DocumentPropertyConstraintViolatedError` (code 10422). It judges the
+     * rules alone, not the document's JSON schema. Throws when the document
+     * belongs to another contract or names a document type this one lacks.
+     * @param {Document} document
+     * @returns {DocumentPropertyConstraintViolation | undefined}
+     */
+    checkDocumentPropertyConstraints(document) {
+        _assertClass(document, Document);
+        const ret = wasm.datacontract_checkDocumentPropertyConstraints(this.__wbg_ptr, document.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @returns {DataContractConfig}
      */
@@ -4144,6 +4198,33 @@ export class DataContract {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * All `propertyConstraints` rules of one document type, in name order,
+     * the order consensus checks them in: each rule's name, the rule as the
+     * schema declares it, every property it reads and how, and whether it
+     * reads `$ownerId` (then a transfer or a purchase is judged against it
+     * too).
+     *
+     * Returns an empty array when the document type declares none. Throws
+     * when the contract has no document type by that name, so "no such
+     * type" and "no rules" stay distinguishable.
+     *
+     * The keyword is only parsed from protocol version 14 onward. A
+     * contract deserialized against an earlier platform version reports
+     * none, which is exactly what consensus enforced at that version, while
+     * `toJSON()` still shows the raw keyword either way.
+     * @param {string} documentTypeName
+     * @returns {Array<DocumentPropertyConstraint>}
+     */
+    documentTypePropertyConstraints(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypePropertyConstraints(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * All `refersTo` declarations of one document type: its `ownerRefersTo`
      * or `creatorRefersTo` first, at the path `$ownerId` or `$creatorId`,
@@ -4241,6 +4322,21 @@ export class DataContract {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every document type that declares `propertyConstraints`, keyed by
+     * document type name.
+     *
+     * Document types with no rules are omitted, so an empty `Map` means
+     * "this contract declares no propertyConstraints at all".
+     * @returns {Map<string, Array<DocumentPropertyConstraint>>}
+     */
+    get documentPropertyConstraints() {
+        const ret = wasm.datacontract_document_property_constraints(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Every document type that declares at least one reference, keyed by
      * document type name.
@@ -4574,6 +4670,47 @@ export class DataContract {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Whether `newContract` is an update of this contract the platform
+     * accepts, judged with the code consensus runs on a data contract update
+     * transition (`DataContract::validate_update`): the owner may not change,
+     * the version must rise by exactly one, the config and every existing
+     * document type follow their update rules, `schemaDefs` stay compatible,
+     * groups and tokens are kept, and an added token's pre-programmed
+     * distributions may not start before the block time.
+     *
+     * Returns the consensus errors a refused update would carry, each with
+     * the `code` a rejected transition reaches JS with, or an empty array
+     * when the update is valid. Most checks stop at the first failure, so a
+     * refused update usually reports one error.
+     *
+     * The two contracts are compared whatever their ids; the platform judges
+     * an update against the stored contract with the new contract's id.
+     * Build `newContract` with full validation
+     * (`DataContract.fromJSON(json, true, platformVersion)`): the transition's
+     * structural checks run there, not here. No state is read, so what the
+     * platform checks against state on top is not covered: that the contract
+     * exists, that group members, identities named by token configurations
+     * and appointed moderators exist, that references into other contracts
+     * resolve, and the signature, nonce and fees.
+     *
+     * `blockInfo` is the block the update would be executed in; only its
+     * time is read. `undefined` lets the device clock stand in for it.
+     * @param {DataContract} newContract
+     * @param {BlockInfo | undefined} blockInfo
+     * @param {PlatformVersionLike} platformVersion
+     * @returns {ConsensusError[]}
+     */
+    validateUpdate(newContract, blockInfo, platformVersion) {
+        _assertClass(newContract, DataContract);
+        const ret = wasm.datacontract_validateUpdate(this.__wbg_ptr, newContract.__wbg_ptr, blockInfo, platformVersion);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @returns {number}
      */
@@ -6494,6 +6631,24 @@ export class Document {
         const ret = wasm.document_id(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
+    /**
+     * The block time at which a moderator of the contract last wrote the fields the document
+     * type keeps for its moderators (`moderatorAbilities.changeFields`); `undefined` until one
+     * does.
+     * @returns {bigint | undefined}
+     */
+    get moderatedAt() {
+        const ret = wasm.document_moderated_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * The moderator who last wrote those fields; `undefined` until one does.
+     * @returns {Identifier | undefined}
+     */
+    get moderatedBy() {
+        const ret = wasm.document_moderated_by(this.__wbg_ptr);
+        return ret === 0 ? undefined : Identifier.__wrap(ret);
+    }
     /**
      * @returns {Identifier}
      */
@@ -7451,6 +7606,35 @@ export const DocumentEncryptionErrorCode = Object.freeze({
     InvalidEncryptedPropertyShape: 10420, "10420": "InvalidEncryptedPropertyShape",
 });
 
+/**
+ * Consensus error codes emitted by the `generatedFrom` check, which runs
+ * from protocol version 14 onward wherever a document is validated, on every
+ * create and replace included.
+ *
+ * Branch on an error's `code` against this instead of matching its message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.create({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentGeneratedFromErrorCode.DocumentPropertyNotGenerated) {
+ *     // a generated property was sent with a value other than what its
+ *     // function generates, or without its params; leaving it out lets
+ *     // the platform generate it
+ *   }
+ * }
+ * ```
+ * @enum {10424}
+ */
+export const DocumentGeneratedFromErrorCode = Object.freeze({
+    /**
+     * A `generatedFrom` string property holds a value other than what its
+     * function generates from its params, or is present while a param is
+     * absent.
+     */
+    DocumentPropertyNotGenerated: 10424, "10424": "DocumentPropertyNotGenerated",
+});
+
 /**
  * Consensus error codes emitted by the immutable-property check on document
  * replaces (`immutable` / `immutableAllowSetting`, protocol version 14+).
@@ -7526,7 +7710,7 @@ export const DocumentMaxBytesErrorCode = Object.freeze({
 export const DocumentPropertyConstraintErrorCode = Object.freeze({
     /**
      * The written document breaks a rule of its document type's
-     * `propertyConstraints`: the comparison does not hold, or evaluating it
+     * `propertyConstraints`: the rule does not hold, or evaluating it
      * overflowed, divided by zero, raised to a negative power or read a value
      * that is not an integer.
      */
@@ -7681,12 +7865,12 @@ if (Symbol.dispose) DocumentPurchaseTransition.prototype[Symbol.dispose] = Docum
  *   }
  * }
  * ```
- * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125 | 40131 | 40135 | 40136 | 40137 | 40138}
+ * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125 | 40131 | 40135 | 40136 | 40137 | 40138 | 40142 | 10423}
  */
 export const DocumentReferenceErrorCode = Object.freeze({
     /**
      * The referenced identity, contract, token or document (permanent or
-     * deletable) does not exist, or a `listElement` value is not an element
+     * deletable) does not exist, or a value with `inList` is not an element
      * of the list it must be in (or was set while the property finding the
      * list's document was not).
      */
@@ -7740,15 +7924,15 @@ export const DocumentReferenceErrorCode = Object.freeze({
      */
     ReferencedIdentityKeyRequirementNotMet: 40136, "40136": "ReferencedIdentityKeyRequirementNotMet",
     /**
-     * A `refersTo` lookup into a document type of another contract cannot
-     * resolve there, reported at contract registration: the named index is
-     * missing or not unique, the keys do not cover it exactly, or a source
-     * holds a different kind of value than its index property. (A lookup into
-     * the declaring contract is refused by the contract parse instead.)
+     * A `refersTo` `findBy` into a document type of another contract cannot
+     * resolve there, reported at contract registration: no unique index is
+     * over exactly the properties it names, or a source holds a different
+     * kind of value than the property it fills. (A `findBy` into the
+     * declaring contract is refused by the contract parse instead.)
      */
     ReferencedDocumentLookupInvalid: 40137, "40137": "ReferencedDocumentLookupInvalid",
     /**
-     * A `refersTo: listElement` whose list lives in a document type of
+     * A `refersTo` with `inList` whose list lives in a document type of
      * another contract cannot be served by it, reported at contract
      * registration: that type's documents can be deleted, the list is not a
      * stored typed array of identifiers of it, or a replace could change the
@@ -7756,6 +7940,19 @@ export const DocumentReferenceErrorCode = Object.freeze({
      * instead.)
      */
     ReferencedDocumentListInvalid: 40138, "40138": "ReferencedDocumentListInvalid",
+    /**
+     * The document a `refersTo` `findBy` function found, the commitment the
+     * create reveals, exists but does not meet the reference's
+     * `minimumAgeBlocks`: it was created too recently, in the same block
+     * with a minimum of 1. Retry in a later block.
+     */
+    ReferencedDocumentRequirementNotMet: 40142, "40142": "ReferencedDocumentRequirementNotMet",
+    /**
+     * A create cannot reveal the preimage of a `refersTo` `findBy`
+     * function: a value a param reads is absent, or a variable-length
+     * value holds the one-byte separator that follows it in the preimage.
+     */
+    DocumentReferencePreimageInvalid: 10423, "10423": "DocumentReferencePreimageInvalid",
 });
 
 export class DocumentReplaceTransition {
@@ -18868,7 +19065,7 @@ export class TimeBasedDistribution {
      * @returns {bigint}
      */
     get interval() {
-        const ret = wasm.__wbg_get_blockbaseddistribution_interval(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_timebaseddistribution_interval(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -25084,7 +25281,7 @@ export class VerifiedNextDistribution {
      * @returns {Vote}
      */
     get vote() {
-        const ret = wasm.__wbg_get_verifiedmasternodevote_vote(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_verifiednextdistribution_vote(this.__wbg_ptr);
         return Vote.__wrap(ret);
     }
     /**
@@ -27642,10 +27839,18 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_consensuserror_new: function(arg0) {
+            const ret = ConsensusError.__wrap(arg0);
+            return ret;
+        },
         __wbg_crypto_86f2631e91b51511: function(arg0) {
             const ret = arg0.crypto;
             return ret;
         },
+        __wbg_defineProperty_14b96efb5b2243dc: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.defineProperty(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_distributionexponential_new: function(arg0) {
             const ret = DistributionExponential.__wrap(arg0);
             return ret;
@@ -27709,7 +27914,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen_208f8721039e7b97___convert__closures_____invoke___wasm_bindgen_208f8721039e7b97___JsValue__wasm_bindgen_208f8721039e7b97___JsValue_____(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_65e1d5bd0ee58ce___convert__closures_____invoke___wasm_bindgen_65e1d5bd0ee58ce___JsValue__wasm_bindgen_65e1d5bd0ee58ce___JsValue_____(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -27723,6 +27928,9 @@ function __wbg_get_imports() {
             const ret = Array.from(arg0);
             return ret;
         },
+        __wbg_getRandomValues_1c61fac11405ffdc: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
         __wbg_getRandomValues_b3f15fcbfabb0f8b: function() { return handleError(function (arg0, arg1) {
             arg0.getRandomValues(arg1);
         }, arguments); },
@@ -27880,6 +28088,10 @@ function __wbg_get_imports() {
             const ret = arg0.node;
             return ret;
         },
+        __wbg_now_a3af9a2f4bbaa4d1: function() {
+            const ret = Date.now();
+            return ret;
+        },
         __wbg_platformaddressinput_new: function(arg0) {
             const ret = PlatformAddressInput.__wrap(arg0);
             return ret;
@@ -28106,8 +28318,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen_208f8721039e7b97___convert__closures_____invoke___wasm_bindgen_208f8721039e7b97___JsValue__wasm_bindgen_208f8721039e7b97___JsValue_____(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen_208f8721039e7b97___convert__closures_____invoke___wasm_bindgen_208f8721039e7b97___JsValue__wasm_bindgen_208f8721039e7b97___JsValue_____(arg0, arg1, arg2, arg3);
+function wasm_bindgen_65e1d5bd0ee58ce___convert__closures_____invoke___wasm_bindgen_65e1d5bd0ee58ce___JsValue__wasm_bindgen_65e1d5bd0ee58ce___JsValue_____(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_65e1d5bd0ee58ce___convert__closures_____invoke___wasm_bindgen_65e1d5bd0ee58ce___JsValue__wasm_bindgen_65e1d5bd0ee58ce___JsValue_____(arg0, arg1, arg2, arg3);
 }
 
 const ActionTakerFinalization = (typeof FinalizationRegistry === 'undefined')