@dashevo/wasm-dpp2 4.2.0-beta.1 → 4.2.0-beta.2

package/dist/raw/wasm_dpp2.no_url.js

@@ -2519,6 +2519,15 @@ export class ConsensusError {
         }
         return ConsensusError.__wrap(ret[0]);
     }
+    /**
+     * The immutable-property error this is, or `undefined` when it is not
+     * code 40128.
+     * @returns {DocumentImmutabilityErrorCode | undefined}
+     */
+    get documentImmutabilityErrorCode() {
+        const ret = wasm.consensuserror_document_immutability_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
     /**
      * The reference-validation error this is, or `undefined` when it is
      * not one of codes 40120-40125.
@@ -3292,6 +3301,32 @@ export class DataContract {
         DataContractFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * The `immutable` / `immutableAllowSetting` declarations of one
+     * document type: `{ immutable: string[], immutableAllowSetting:
+     * string[] }`, both sorted by property name.
+     *
+     * Both arrays are empty when the document type declares nothing (the
+     * normal case, and the only case for a type whose documents are not
+     * mutable). Throws when the contract has no document type by that
+     * name, so "no such type" and "nothing frozen" stay distinguishable.
+     *
+     * The keywords are only parsed from protocol version 14 onward. A
+     * contract deserialized against an earlier platform version reports
+     * empty lists, which is exactly what consensus enforced at that
+     * version, while `toJSON()` still shows the raw keywords either way.
+     * @param {string} documentTypeName
+     * @returns {DocumentTypeImmutableProperties}
+     */
+    documentTypeImmutableProperties(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypeImmutableProperties(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * All `refersTo` declarations of one document type, in schema property
      * order.
@@ -3318,6 +3353,21 @@ export class DataContract {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every document type that freezes at least one property, keyed by
+     * document type name.
+     *
+     * Document types with an empty `immutable` list are omitted, so an
+     * empty `Map` means "nothing in this contract is frozen per property".
+     * @returns {Map<string, DocumentTypeImmutableProperties>}
+     */
+    get documentImmutableProperties() {
+        const ret = wasm.datacontract_document_immutable_properties(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.
@@ -6253,6 +6303,32 @@ export class DocumentDeleteTransition {
 }
 if (Symbol.dispose) DocumentDeleteTransition.prototype[Symbol.dispose] = DocumentDeleteTransition.prototype.free;
 
+/**
+ * Consensus error codes emitted by the immutable-property check on document
+ * replaces (`immutable` / `immutableAllowSetting`, protocol version 14+).
+ *
+ * Branch on an error's `code` against this instead of matching its message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.replace({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentImmutabilityErrorCode.DocumentImmutablePropertyChanged) {
+ *     // the replace touched a property the document type freezes
+ *   }
+ * }
+ * ```
+ * @enum {40128}
+ */
+export const DocumentImmutabilityErrorCode = Object.freeze({
+    /**
+     * The replace changed, added or removed a property the document type
+     * lists under `immutable`, and the change was not the one first-time
+     * set `immutableAllowSetting` permits.
+     */
+    DocumentImmutablePropertyChanged: 40128, "40128": "DocumentImmutablePropertyChanged",
+});
+
 export class DocumentPurchaseTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -10652,6 +10728,352 @@ export class IdentityCreditWithdrawalTransition {
 }
 if (Symbol.dispose) IdentityCreditWithdrawalTransition.prototype[Symbol.dispose] = IdentityCreditWithdrawalTransition.prototype.free;
 
+export class IdentityKeyLimitsUpdate {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityKeyLimitsUpdate.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityKeyLimitsUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityKeyLimitsUpdateFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitykeylimitsupdate_free(ptr, 0);
+    }
+    /**
+     * @param {IdentityKeyLimitsUpdateTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.identitykeylimitsupdate_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityKeyLimitsUpdateFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get expiresAt() {
+        const ret = wasm.identitykeylimitsupdate_expires_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @param {string} base64
+     * @returns {IdentityKeyLimitsUpdate}
+     */
+    static fromBase64(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitykeylimitsupdate_fromBase64(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {IdentityKeyLimitsUpdate}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitykeylimitsupdate_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} hex
+     * @returns {IdentityKeyLimitsUpdate}
+     */
+    static fromHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitykeylimitsupdate_fromHex(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityKeyLimitsUpdateJSON} js
+     * @returns {IdentityKeyLimitsUpdate}
+     */
+    static fromJSON(js) {
+        const ret = wasm.identitykeylimitsupdate_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityKeyLimitsUpdateObject} obj
+     * @returns {IdentityKeyLimitsUpdate}
+     */
+    static fromObject(obj) {
+        const ret = wasm.identitykeylimitsupdate_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
+    }
+    /**
+     * @param {StateTransition} st
+     * @returns {IdentityKeyLimitsUpdate}
+     */
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.identitykeylimitsupdate_fromStateTransition(st.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get identityId() {
+        const ret = wasm.identitykeylimitsupdate_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get keyId() {
+        const ret = wasm.identitykeylimitsupdate_key_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get nonce() {
+        const ret = wasm.identitykeylimitsupdate_nonce(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {bigint | null} [expires_at]
+     */
+    set expiresAt(expires_at) {
+        const ret = wasm.identitykeylimitsupdate_set_expires_at(this.__wbg_ptr, isLikeNone(expires_at) ? 0 : addToExternrefTable0(expires_at));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {IdentifierLike} identity_id
+     */
+    set identityId(identity_id) {
+        const ret = wasm.identitykeylimitsupdate_set_identity_id(this.__wbg_ptr, identity_id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} key_id
+     */
+    set keyId(key_id) {
+        const ret = wasm.identitykeylimitsupdate_set_key_id(this.__wbg_ptr, key_id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {bigint} nonce
+     */
+    set nonce(nonce) {
+        const ret = wasm.identitykeylimitsupdate_set_nonce(this.__wbg_ptr, nonce);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Uint8Array} signature
+     */
+    set signature(signature) {
+        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.identitykeylimitsupdate_set_signature(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} publicKeyId
+     */
+    set signaturePublicKeyId(publicKeyId) {
+        const ret = wasm.identitykeylimitsupdate_set_signature_public_key_id(this.__wbg_ptr, publicKeyId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {bigint | null} [total_budget]
+     */
+    set totalBudget(total_budget) {
+        const ret = wasm.identitykeylimitsupdate_set_total_budget(this.__wbg_ptr, isLikeNone(total_budget) ? 0 : addToExternrefTable0(total_budget));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} amount
+     */
+    set userFeeIncrease(amount) {
+        const ret = wasm.identitykeylimitsupdate_set_user_fee_increase(this.__wbg_ptr, amount);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.identitykeylimitsupdate_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get signaturePublicKeyId() {
+        const ret = wasm.identitykeylimitsupdate_signature_public_key_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_struct_name();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    toBase64() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_toBase64(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.identitykeylimitsupdate_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    toHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_toHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {IdentityKeyLimitsUpdateJSON}
+     */
+    toJSON() {
+        const ret = wasm.identitykeylimitsupdate_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {IdentityKeyLimitsUpdateObject}
+     */
+    toObject() {
+        const ret = wasm.identitykeylimitsupdate_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.identitykeylimitsupdate_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get totalBudget() {
+        const ret = wasm.identitykeylimitsupdate_total_budget(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_type_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get userFeeIncrease() {
+        const ret = wasm.identitykeylimitsupdate_user_fee_increase(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) IdentityKeyLimitsUpdate.prototype[Symbol.dispose] = IdentityKeyLimitsUpdate.prototype.free;
+
 export class IdentityPublicKey {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -10732,6 +11154,15 @@ export class IdentityPublicKey {
         const ret = wasm.identitypublickey_disabled_at(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
+    /**
+     * The block time in milliseconds from which the key can no longer sign, `undefined` when
+     * it does not expire
+     * @returns {bigint | undefined}
+     */
+    get expiresAt() {
+        const ret = wasm.identitypublickey_expires_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @param {string} hex
      * @returns {IdentityPublicKey}
@@ -10957,6 +11388,16 @@ export class IdentityPublicKey {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Setting an expiry on a version 0 key makes it a version 1 key
+     * @param {bigint | null} [expiresAt]
+     */
+    set expiresAt(expiresAt) {
+        const ret = wasm.identitypublickey_set_expires_at(this.__wbg_ptr, isLikeNone(expiresAt) ? 0 : addToExternrefTable0(expiresAt));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {boolean} isReadOnly
      */
@@ -10999,6 +11440,16 @@ export class IdentityPublicKey {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Setting a budget on a version 0 key makes it a version 1 key
+     * @param {bigint | null} [totalBudget]
+     */
+    set totalBudget(totalBudget) {
+        const ret = wasm.identitypublickey_set_total_budget(this.__wbg_ptr, isLikeNone(totalBudget) ? 0 : addToExternrefTable0(totalBudget));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {string}
      */
@@ -11057,6 +11508,14 @@ export class IdentityPublicKey {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The total credits the key may spend over its lifetime, `undefined` when it has no budget
+     * @returns {bigint | undefined}
+     */
+    get totalBudget() {
+        const ret = wasm.identitypublickey_total_budget(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @returns {string}
      */
@@ -11135,6 +11594,15 @@ export class IdentityPublicKeyInCreation {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * The block time in milliseconds from which the key can no longer sign, `undefined` when
+     * it does not expire
+     * @returns {bigint | undefined}
+     */
+    get expiresAt() {
+        const ret = wasm.identitypublickeyincreation_expires_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @param {IdentityPublicKeyInCreationJSON} js
      * @returns {IdentityPublicKeyInCreation}
@@ -11247,6 +11715,17 @@ export class IdentityPublicKeyInCreation {
         const len0 = WASM_VECTOR_LEN;
         wasm.identitypublickeyincreation_set_data(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Setting an expiry on a version 0 key makes it a version 1 key. The key's own signature
+     * no longer covers it afterwards: sign again.
+     * @param {bigint | null} [expiresAt]
+     */
+    set expiresAt(expiresAt) {
+        const ret = wasm.identitypublickeyincreation_set_expires_at(this.__wbg_ptr, isLikeNone(expiresAt) ? 0 : addToExternrefTable0(expiresAt));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {boolean} isReadOnly
      */
@@ -11297,6 +11776,17 @@ export class IdentityPublicKeyInCreation {
         const len0 = WASM_VECTOR_LEN;
         wasm.identitypublickeyincreation_set_signature(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Setting a budget on a version 0 key makes it a version 1 key. The key's own signature
+     * no longer covers it afterwards: sign again.
+     * @param {bigint | null} [totalBudget]
+     */
+    set totalBudget(totalBudget) {
+        const ret = wasm.identitypublickeyincreation_set_total_budget(this.__wbg_ptr, isLikeNone(totalBudget) ? 0 : addToExternrefTable0(totalBudget));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {Uint8Array}
      */
@@ -11348,6 +11838,14 @@ export class IdentityPublicKeyInCreation {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The credits the key may spend over its lifetime, `undefined` when it has no budget
+     * @returns {bigint | undefined}
+     */
+    get totalBudget() {
+        const ret = wasm.identitypublickeyincreation_total_budget(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @returns {string}
      */
@@ -25849,6 +26347,9 @@ const IdentityCreditTransferToAddressesFinalization = (typeof FinalizationRegist
 const IdentityCreditWithdrawalTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitycreditwithdrawaltransition_free(ptr >>> 0, 1));
+const IdentityKeyLimitsUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitykeylimitsupdate_free(ptr >>> 0, 1));
 const IdentityPublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitypublickey_free(ptr >>> 0, 1));