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

package/dist/raw/wasm_dpp2.no_url.js

@@ -3083,68 +3083,139 @@ export class ContractBounds {
 }
 if (Symbol.dispose) ContractBounds.prototype[Symbol.dispose] = ContractBounds.prototype.free;
 
-export class CoreScript {
+export class ContractFeeClaim {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(CoreScript.prototype);
+        const obj = Object.create(ContractFeeClaim.prototype);
         obj.__wbg_ptr = ptr;
-        CoreScriptFinalization.register(obj, obj.__wbg_ptr, obj);
+        ContractFeeClaimFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CoreScriptFinalization.unregister(this);
+        ContractFeeClaimFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_corescript_free(ptr, 0);
+        wasm.__wbg_contractfeeclaim_free(ptr, 0);
+    }
+    /**
+     * @param {ContractFeeClaimTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.contractfeeclaim_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ContractFeeClaimFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get dataContractId() {
+        const ret = wasm.contractfeeclaim_data_contract_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @param {string} base64
+     * @returns {ContractFeeClaim}
+     */
+    static fromBase64(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.contractfeeclaim_fromBase64(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractFeeClaim.__wrap(ret[0]);
     }
     /**
      * @param {Uint8Array} bytes
-     * @returns {CoreScript}
+     * @returns {ContractFeeClaim}
      */
     static fromBytes(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.corescript_fromBytes(ptr0, len0);
-        return CoreScript.__wrap(ret);
+        const ret = wasm.contractfeeclaim_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractFeeClaim.__wrap(ret[0]);
     }
     /**
-     * @param {Uint8Array} keyHash
-     * @returns {CoreScript}
+     * @param {string} hex
+     * @returns {ContractFeeClaim}
      */
-    static fromP2PKH(keyHash) {
-        const ptr0 = passArray8ToWasm0(keyHash, wasm.__wbindgen_malloc);
+    static fromHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.corescript_fromP2PKH(ptr0, len0);
+        const ret = wasm.contractfeeclaim_fromHex(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return CoreScript.__wrap(ret[0]);
+        return ContractFeeClaim.__wrap(ret[0]);
     }
     /**
-     * @param {Uint8Array} scriptHash
-     * @returns {CoreScript}
+     * @param {ContractFeeClaimJSON} js
+     * @returns {ContractFeeClaim}
      */
-    static fromP2SH(scriptHash) {
-        const ptr0 = passArray8ToWasm0(scriptHash, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.corescript_fromP2SH(ptr0, len0);
+    static fromJSON(js) {
+        const ret = wasm.contractfeeclaim_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return CoreScript.__wrap(ret[0]);
+        return ContractFeeClaim.__wrap(ret[0]);
+    }
+    /**
+     * @param {ContractFeeClaimObject} obj
+     * @returns {ContractFeeClaim}
+     */
+    static fromObject(obj) {
+        const ret = wasm.contractfeeclaim_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractFeeClaim.__wrap(ret[0]);
+    }
+    /**
+     * @param {StateTransition} st
+     * @returns {ContractFeeClaim}
+     */
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.contractfeeclaim_fromStateTransition(st.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractFeeClaim.__wrap(ret[0]);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get identityContractNonce() {
+        const ret = wasm.contractfeeclaim_identity_contract_nonce(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get ownerId() {
+        const ret = wasm.contractfeeclaim_owner_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
+     * The pot that is paid out: owner or moderators
      * @returns {string}
      */
-    static get __struct() {
+    get pot() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.corescript_struct_name();
+            const ret = wasm.contractfeeclaim_pot(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3152,14 +3223,94 @@ export class CoreScript {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {IdentifierLike} id
+     */
+    set dataContractId(id) {
+        const ret = wasm.contractfeeclaim_set_data_contract_id(this.__wbg_ptr, id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {bigint} nonce
+     */
+    set identityContractNonce(nonce) {
+        const ret = wasm.contractfeeclaim_set_identity_contract_nonce(this.__wbg_ptr, nonce);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {IdentifierLike} owner_id
+     */
+    set ownerId(owner_id) {
+        const ret = wasm.contractfeeclaim_set_owner_id(this.__wbg_ptr, owner_id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} pot
+     */
+    set pot(pot) {
+        const ptr0 = passStringToWasm0(pot, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.contractfeeclaim_set_pot(this.__wbg_ptr, ptr0, len0);
+        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.contractfeeclaim_set_signature(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} publicKeyId
+     */
+    set signaturePublicKeyId(publicKeyId) {
+        const ret = wasm.contractfeeclaim_set_signature_public_key_id(this.__wbg_ptr, publicKeyId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} amount
+     */
+    set userFeeIncrease(amount) {
+        const ret = wasm.contractfeeclaim_set_user_fee_increase(this.__wbg_ptr, amount);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.contractfeeclaim_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.contractfeeclaim_signature_public_key_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @returns {string}
      */
-    toASMString() {
+    static get __struct() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.corescript_toASMString(this.__wbg_ptr);
+            const ret = wasm.contractfeeclaim_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3168,14 +3319,13 @@ export class CoreScript {
         }
     }
     /**
-     * @param {NetworkLike} network
      * @returns {string}
      */
-    toAddress(network) {
+    toBase64() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.corescript_toAddress(this.__wbg_ptr, network);
+            const ret = wasm.contractfeeclaim_toBase64(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -3189,26 +3339,14 @@ export class CoreScript {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
-    /**
-     * @returns {string}
-     */
-    toBase64() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.corescript_toBase64(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 {Uint8Array}
      */
     toBytes() {
-        const ret = wasm.corescript_toBytes(this.__wbg_ptr);
+        const ret = wasm.contractfeeclaim_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;
@@ -3217,31 +3355,49 @@ export class CoreScript {
      * @returns {string}
      */
     toHex() {
-        let deferred1_0;
-        let deferred1_1;
+        let deferred2_0;
+        let deferred2_1;
         try {
-            const ret = wasm.corescript_toHex(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
+            const ret = wasm.contractfeeclaim_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(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
     /**
-     * @returns {string}
+     * @returns {ContractFeeClaimJSON}
      */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.corescript_toString(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);
+    toJSON() {
+        const ret = wasm.contractfeeclaim_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {ContractFeeClaimObject}
+     */
+    toObject() {
+        const ret = wasm.contractfeeclaim_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.contractfeeclaim_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
     }
     /**
      * @returns {string}
@@ -3250,7 +3406,7 @@ export class CoreScript {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.corescript_type_name(this.__wbg_ptr);
+            const ret = wasm.contractfeeclaim_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3258,314 +3414,262 @@ export class CoreScript {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {number}
+     */
+    get userFeeIncrease() {
+        const ret = wasm.contractfeeclaim_user_fee_increase(this.__wbg_ptr);
+        return ret;
+    }
 }
-if (Symbol.dispose) CoreScript.prototype[Symbol.dispose] = CoreScript.prototype.free;
+if (Symbol.dispose) ContractFeeClaim.prototype[Symbol.dispose] = ContractFeeClaim.prototype.free;
 
-export class DataContract {
+export class ContractUserModeration {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(DataContract.prototype);
+        const obj = Object.create(ContractUserModeration.prototype);
         obj.__wbg_ptr = ptr;
-        DataContractFinalization.register(obj, obj.__wbg_ptr, obj);
+        ContractUserModerationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        DataContractFinalization.unregister(this);
+        ContractUserModerationFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_datacontract_free(ptr, 0);
+        wasm.__wbg_contractusermoderation_free(ptr, 0);
     }
     /**
-     * @returns {DataContractConfig}
+     * The action's name: ban, unban, suspend, unsuspend or deleteDocument
+     * @returns {string}
      */
-    get config() {
-        const ret = wasm.datacontract_config(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    get action() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.contractusermoderation_action(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);
         }
-        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @param {DataContractOptions} options
+     * @param {ContractUserModerationTransitionOptions} options
      */
     constructor(options) {
-        const ret = wasm.datacontract_constructor(options);
+        const ret = wasm.contractusermoderation_constructor(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        DataContractFinalization.register(this, this.__wbg_ptr, this);
+        ContractUserModerationFinalization.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.
-     *
-     * Returns an empty array when the document type declares none. Throws
-     * when the contract has no document type by that name — an empty array
-     * would conflate "no such type" with "no references".
-     *
-     * Reference declarations are 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 — but note the trap: `DataContract.fromBytes(bytes, false, 1)`
-     * yields `[]` even for a contract whose raw schema does carry
-     * `refersTo`, and `toJSON()` still shows the raw keyword either way.
-     * @param {string} documentTypeName
-     * @returns {Array<DocumentPropertyReference>}
+     * @returns {Identifier}
      */
-    documentTypeReferences(documentTypeName) {
-        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.datacontract_documentTypeReferences(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    get dataContractId() {
+        const ret = wasm.contractusermoderation_data_contract_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
-     * 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>}
+     * For a deleteDocument, the document it deletes
+     * @returns {Identifier | undefined}
      */
-    get documentImmutableProperties() {
-        const ret = wasm.datacontract_document_immutable_properties(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    get documentId() {
+        const ret = wasm.contractusermoderation_document_id(this.__wbg_ptr);
+        return ret === 0 ? undefined : Identifier.__wrap(ret);
     }
     /**
-     * Every document type that declares at least one reference, keyed by
-     * document type name.
-     *
-     * Document types with no declarations are omitted, so an empty `Map`
-     * means "this contract declares no references at all".
-     * @returns {Map<string, Array<DocumentPropertyReference>>}
+     * For a deleteDocument, the document type of the document it deletes
+     * @returns {string | undefined}
      */
-    get documentReferences() {
-        const ret = wasm.datacontract_document_references(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    get documentTypeName() {
+        const ret = wasm.contractusermoderation_document_type_name(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return v1;
     }
     /**
      * @param {string} base64
-     * @param {boolean} full_validation
-     * @param {PlatformVersionLike} platform_version
-     * @returns {DataContract}
+     * @returns {ContractUserModeration}
      */
-    static fromBase64(base64, full_validation, platform_version) {
+    static fromBase64(base64) {
         const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.datacontract_fromBase64(ptr0, len0, full_validation, platform_version);
+        const ret = wasm.contractusermoderation_fromBase64(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return DataContract.__wrap(ret[0]);
+        return ContractUserModeration.__wrap(ret[0]);
     }
     /**
      * @param {Uint8Array} bytes
-     * @param {boolean} full_validation
-     * @param {PlatformVersionLike} platform_version
-     * @returns {DataContract}
+     * @returns {ContractUserModeration}
      */
-    static fromBytes(bytes, full_validation, platform_version) {
+    static fromBytes(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.datacontract_fromBytes(ptr0, len0, full_validation, platform_version);
+        const ret = wasm.contractusermoderation_fromBytes(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return DataContract.__wrap(ret[0]);
+        return ContractUserModeration.__wrap(ret[0]);
     }
     /**
      * @param {string} hex
-     * @param {boolean} full_validation
-     * @param {PlatformVersionLike} platform_version
-     * @returns {DataContract}
+     * @returns {ContractUserModeration}
      */
-    static fromHex(hex, full_validation, platform_version) {
+    static fromHex(hex) {
         const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.datacontract_fromHex(ptr0, len0, full_validation, platform_version);
+        const ret = wasm.contractusermoderation_fromHex(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return DataContract.__wrap(ret[0]);
+        return ContractUserModeration.__wrap(ret[0]);
     }
     /**
-     * @param {DataContractJSON} value
-     * @param {boolean} full_validation
-     * @param {PlatformVersionLike} platform_version
-     * @returns {DataContract}
+     * @param {ContractUserModerationJSON} js
+     * @returns {ContractUserModeration}
      */
-    static fromJSON(value, full_validation, platform_version) {
-        const ret = wasm.datacontract_fromJSON(value, full_validation, platform_version);
+    static fromJSON(js) {
+        const ret = wasm.contractusermoderation_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return DataContract.__wrap(ret[0]);
+        return ContractUserModeration.__wrap(ret[0]);
     }
     /**
-     * @param {DataContractObject} value
-     * @param {boolean} full_validation
-     * @param {PlatformVersionLike} platform_version
-     * @returns {DataContract}
+     * @param {ContractUserModerationObject} obj
+     * @returns {ContractUserModeration}
      */
-    static fromObject(value, full_validation, platform_version) {
-        const ret = wasm.datacontract_fromObject(value, full_validation, platform_version);
+    static fromObject(obj) {
+        const ret = wasm.contractusermoderation_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return DataContract.__wrap(ret[0]);
+        return ContractUserModeration.__wrap(ret[0]);
     }
     /**
-     * @param {IdentifierLike} owner_id
-     * @param {bigint} identity_nonce
-     * @returns {Identifier}
+     * @param {StateTransition} st
+     * @returns {ContractUserModeration}
      */
-    static generateId(owner_id, identity_nonce) {
-        const ret = wasm.datacontract_generateId(owner_id, identity_nonce);
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.contractusermoderation_fromStateTransition(st.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return Identifier.__wrap(ret[0]);
+        return ContractUserModeration.__wrap(ret[0]);
     }
     /**
-     * @returns {Record<number, Group>}
+     * @returns {bigint}
      */
-    get groups() {
-        const ret = wasm.datacontract_groups(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    get identityContractNonce() {
+        const ret = wasm.contractusermoderation_identity_contract_nonce(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * @returns {Identifier}
+     * The identity the action targets, undefined for a deleteDocument: it names a document,
+     * and whose it is is only known once the document is read
+     * @returns {Identifier | undefined}
      */
-    get id() {
-        const ret = wasm.datacontract_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+    get identityId() {
+        const ret = wasm.contractusermoderation_identity_id(this.__wbg_ptr);
+        return ret === 0 ? undefined : Identifier.__wrap(ret);
     }
     /**
      * @returns {Identifier}
      */
     get ownerId() {
-        const ret = wasm.datacontract_owner_id(this.__wbg_ptr);
+        const ret = wasm.contractusermoderation_owner_id(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
     /**
-     * @returns {Record<string, object>}
+     * For a ban, a suspend and a deleteDocument, why
+     * @returns {ContractModerationReason | undefined}
      */
-    get schemas() {
-        const ret = wasm.datacontract_schemas(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    get reason() {
+        const ret = wasm.contractusermoderation_reason(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {DataContractConfig} config
-     * @param {PlatformVersionLike} platformVersion
+     * @param {IdentifierLike} id
      */
-    setConfig(config, platformVersion) {
-        const ret = wasm.datacontract_setConfig(this.__wbg_ptr, config, platformVersion);
+    set dataContractId(id) {
+        const ret = wasm.contractusermoderation_set_data_contract_id(this.__wbg_ptr, id);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param {Record<string, object>} schemas
-     * @param {object | null | undefined} definitions
-     * @param {boolean} full_validation
-     * @param {PlatformVersionLike} platform_version
+     * @param {bigint} nonce
      */
-    setSchemas(schemas, definitions, full_validation, platform_version) {
-        const ret = wasm.datacontract_setSchemas(this.__wbg_ptr, schemas, isLikeNone(definitions) ? 0 : addToExternrefTable0(definitions), full_validation, platform_version);
+    set identityContractNonce(nonce) {
+        const ret = wasm.contractusermoderation_set_identity_contract_nonce(this.__wbg_ptr, nonce);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param {Record<number, Group>} groups
+     * @param {IdentifierLike} owner_id
      */
-    set groups(groups) {
-        const ret = wasm.datacontract_set_groups(this.__wbg_ptr, groups);
+    set ownerId(owner_id) {
+        const ret = wasm.contractusermoderation_set_owner_id(this.__wbg_ptr, owner_id);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param {IdentifierLike} id
+     * @param {Uint8Array} signature
      */
-    set id(id) {
-        const ret = wasm.datacontract_set_id(this.__wbg_ptr, id);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    set signature(signature) {
+        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.contractusermoderation_set_signature(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {IdentifierLike} ownerId
+     * @param {number} publicKeyId
      */
-    set ownerId(ownerId) {
-        const ret = wasm.datacontract_set_owner_id(this.__wbg_ptr, ownerId);
+    set signaturePublicKeyId(publicKeyId) {
+        const ret = wasm.contractusermoderation_set_signature_public_key_id(this.__wbg_ptr, publicKeyId);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param {Record<number, TokenConfiguration>} tokens
+     * @param {number} amount
      */
-    set tokens(tokens) {
-        const ret = wasm.datacontract_set_tokens(this.__wbg_ptr, tokens);
+    set userFeeIncrease(amount) {
+        const ret = wasm.contractusermoderation_set_user_fee_increase(this.__wbg_ptr, amount);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * @param {number} version
+     * @returns {Uint8Array}
      */
-    set version(version) {
-        const ret = wasm.datacontract_set_version(this.__wbg_ptr, version);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    get signature() {
+        const ret = wasm.contractusermoderation_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.contractusermoderation_signature_public_key_id(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * @returns {string}
@@ -3574,7 +3678,7 @@ export class DataContract {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.datacontract_struct_name();
+            const ret = wasm.contractusermoderation_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3583,14 +3687,13 @@ export class DataContract {
         }
     }
     /**
-     * @param {PlatformVersionLike} platformVersion
      * @returns {string}
      */
-    toBase64(platformVersion) {
+    toBase64() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.datacontract_toBase64(this.__wbg_ptr, platformVersion);
+            const ret = wasm.contractusermoderation_toBase64(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -3605,11 +3708,10 @@ export class DataContract {
         }
     }
     /**
-     * @param {PlatformVersionLike} platformVersion
      * @returns {Uint8Array}
      */
-    toBytes(platformVersion) {
-        const ret = wasm.datacontract_toBytes(this.__wbg_ptr, platformVersion);
+    toBytes() {
+        const ret = wasm.contractusermoderation_toBytes(this.__wbg_ptr);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -3618,14 +3720,13 @@ export class DataContract {
         return v1;
     }
     /**
-     * @param {PlatformVersionLike} platformVersion
      * @returns {string}
      */
-    toHex(platformVersion) {
+    toHex() {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.datacontract_toHex(this.__wbg_ptr, platformVersion);
+            const ret = wasm.contractusermoderation_toHex(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -3640,36 +3741,31 @@ export class DataContract {
         }
     }
     /**
-     * @param {PlatformVersionLike} platform_version
-     * @returns {DataContractJSON}
+     * @returns {ContractUserModerationJSON}
      */
-    toJSON(platform_version) {
-        const ret = wasm.datacontract_toJSON(this.__wbg_ptr, platform_version);
+    toJSON() {
+        const ret = wasm.contractusermoderation_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @param {PlatformVersionLike} platformVersion
-     * @returns {DataContractObject}
+     * @returns {ContractUserModerationObject}
      */
-    toObject(platformVersion) {
-        const ret = wasm.datacontract_toObject(this.__wbg_ptr, platformVersion);
+    toObject() {
+        const ret = wasm.contractusermoderation_toObject(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {object}
+     * @returns {StateTransition}
      */
-    get tokens() {
-        const ret = wasm.datacontract_tokens(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+    toStateTransition() {
+        const ret = wasm.contractusermoderation_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
     }
     /**
      * @returns {string}
@@ -3678,7 +3774,7 @@ export class DataContract {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.datacontract_type_name(this.__wbg_ptr);
+            const ret = wasm.contractusermoderation_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3686,20 +3782,641 @@ export class DataContract {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * For a suspend, the block time in milliseconds at which the suspension lapses
+     * @returns {bigint | undefined}
+     */
+    get until() {
+        const ret = wasm.contractusermoderation_until(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @returns {number}
      */
-    get version() {
-        const ret = wasm.datacontract_version(this.__wbg_ptr);
-        return ret >>> 0;
+    get userFeeIncrease() {
+        const ret = wasm.contractusermoderation_user_fee_increase(this.__wbg_ptr);
+        return ret;
     }
 }
-if (Symbol.dispose) DataContract.prototype[Symbol.dispose] = DataContract.prototype.free;
+if (Symbol.dispose) ContractUserModeration.prototype[Symbol.dispose] = ContractUserModeration.prototype.free;
 
-export class DataContractCreateTransition {
+export class CoreScript {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(DataContractCreateTransition.prototype);
+        const obj = Object.create(CoreScript.prototype);
+        obj.__wbg_ptr = ptr;
+        CoreScriptFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CoreScriptFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_corescript_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {CoreScript}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.corescript_fromBytes(ptr0, len0);
+        return CoreScript.__wrap(ret);
+    }
+    /**
+     * @param {Uint8Array} keyHash
+     * @returns {CoreScript}
+     */
+    static fromP2PKH(keyHash) {
+        const ptr0 = passArray8ToWasm0(keyHash, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.corescript_fromP2PKH(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CoreScript.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} scriptHash
+     * @returns {CoreScript}
+     */
+    static fromP2SH(scriptHash) {
+        const ptr0 = passArray8ToWasm0(scriptHash, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.corescript_fromP2SH(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CoreScript.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.corescript_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}
+     */
+    toASMString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.corescript_toASMString(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);
+        }
+    }
+    /**
+     * @param {NetworkLike} network
+     * @returns {string}
+     */
+    toAddress(network) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.corescript_toAddress(this.__wbg_ptr, network);
+            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 {string}
+     */
+    toBase64() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.corescript_toBase64(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 {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.corescript_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    toHex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.corescript_toHex(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 {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.corescript_toString(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 {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.corescript_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);
+        }
+    }
+}
+if (Symbol.dispose) CoreScript.prototype[Symbol.dispose] = CoreScript.prototype.free;
+
+export class DataContract {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DataContract.prototype);
+        obj.__wbg_ptr = ptr;
+        DataContractFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DataContractFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_datacontract_free(ptr, 0);
+    }
+    /**
+     * @returns {DataContractConfig}
+     */
+    get config() {
+        const ret = wasm.datacontract_config(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {DataContractOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.datacontract_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        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.
+     *
+     * Returns an empty array when the document type declares none. Throws
+     * when the contract has no document type by that name — an empty array
+     * would conflate "no such type" with "no references".
+     *
+     * Reference declarations are 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 — but note the trap: `DataContract.fromBytes(bytes, false, 1)`
+     * yields `[]` even for a contract whose raw schema does carry
+     * `refersTo`, and `toJSON()` still shows the raw keyword either way.
+     * @param {string} documentTypeName
+     * @returns {Array<DocumentPropertyReference>}
+     */
+    documentTypeReferences(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypeReferences(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        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.
+     *
+     * Document types with no declarations are omitted, so an empty `Map`
+     * means "this contract declares no references at all".
+     * @returns {Map<string, Array<DocumentPropertyReference>>}
+     */
+    get documentReferences() {
+        const ret = wasm.datacontract_document_references(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} base64
+     * @param {boolean} full_validation
+     * @param {PlatformVersionLike} platform_version
+     * @returns {DataContract}
+     */
+    static fromBase64(base64, full_validation, platform_version) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_fromBase64(ptr0, len0, full_validation, platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DataContract.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @param {boolean} full_validation
+     * @param {PlatformVersionLike} platform_version
+     * @returns {DataContract}
+     */
+    static fromBytes(bytes, full_validation, platform_version) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_fromBytes(ptr0, len0, full_validation, platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DataContract.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} hex
+     * @param {boolean} full_validation
+     * @param {PlatformVersionLike} platform_version
+     * @returns {DataContract}
+     */
+    static fromHex(hex, full_validation, platform_version) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_fromHex(ptr0, len0, full_validation, platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DataContract.__wrap(ret[0]);
+    }
+    /**
+     * @param {DataContractJSON} value
+     * @param {boolean} full_validation
+     * @param {PlatformVersionLike} platform_version
+     * @returns {DataContract}
+     */
+    static fromJSON(value, full_validation, platform_version) {
+        const ret = wasm.datacontract_fromJSON(value, full_validation, platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DataContract.__wrap(ret[0]);
+    }
+    /**
+     * @param {DataContractObject} value
+     * @param {boolean} full_validation
+     * @param {PlatformVersionLike} platform_version
+     * @returns {DataContract}
+     */
+    static fromObject(value, full_validation, platform_version) {
+        const ret = wasm.datacontract_fromObject(value, full_validation, platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DataContract.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentifierLike} owner_id
+     * @param {bigint} identity_nonce
+     * @returns {Identifier}
+     */
+    static generateId(owner_id, identity_nonce) {
+        const ret = wasm.datacontract_generateId(owner_id, identity_nonce);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Identifier.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Record<number, Group>}
+     */
+    get groups() {
+        const ret = wasm.datacontract_groups(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.datacontract_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get ownerId() {
+        const ret = wasm.datacontract_owner_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {Record<string, object>}
+     */
+    get schemas() {
+        const ret = wasm.datacontract_schemas(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {DataContractConfig} config
+     * @param {PlatformVersionLike} platformVersion
+     */
+    setConfig(config, platformVersion) {
+        const ret = wasm.datacontract_setConfig(this.__wbg_ptr, config, platformVersion);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Record<string, object>} schemas
+     * @param {object | null | undefined} definitions
+     * @param {boolean} full_validation
+     * @param {PlatformVersionLike} platform_version
+     */
+    setSchemas(schemas, definitions, full_validation, platform_version) {
+        const ret = wasm.datacontract_setSchemas(this.__wbg_ptr, schemas, isLikeNone(definitions) ? 0 : addToExternrefTable0(definitions), full_validation, platform_version);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Record<number, Group>} groups
+     */
+    set groups(groups) {
+        const ret = wasm.datacontract_set_groups(this.__wbg_ptr, groups);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {IdentifierLike} id
+     */
+    set id(id) {
+        const ret = wasm.datacontract_set_id(this.__wbg_ptr, id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {IdentifierLike} ownerId
+     */
+    set ownerId(ownerId) {
+        const ret = wasm.datacontract_set_owner_id(this.__wbg_ptr, ownerId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Record<number, TokenConfiguration>} tokens
+     */
+    set tokens(tokens) {
+        const ret = wasm.datacontract_set_tokens(this.__wbg_ptr, tokens);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} version
+     */
+    set version(version) {
+        const ret = wasm.datacontract_set_version(this.__wbg_ptr, version);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.datacontract_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);
+        }
+    }
+    /**
+     * @param {PlatformVersionLike} platformVersion
+     * @returns {string}
+     */
+    toBase64(platformVersion) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.datacontract_toBase64(this.__wbg_ptr, platformVersion);
+            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);
+        }
+    }
+    /**
+     * @param {PlatformVersionLike} platformVersion
+     * @returns {Uint8Array}
+     */
+    toBytes(platformVersion) {
+        const ret = wasm.datacontract_toBytes(this.__wbg_ptr, platformVersion);
+        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;
+    }
+    /**
+     * @param {PlatformVersionLike} platformVersion
+     * @returns {string}
+     */
+    toHex(platformVersion) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.datacontract_toHex(this.__wbg_ptr, platformVersion);
+            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);
+        }
+    }
+    /**
+     * @param {PlatformVersionLike} platform_version
+     * @returns {DataContractJSON}
+     */
+    toJSON(platform_version) {
+        const ret = wasm.datacontract_toJSON(this.__wbg_ptr, platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {PlatformVersionLike} platformVersion
+     * @returns {DataContractObject}
+     */
+    toObject(platformVersion) {
+        const ret = wasm.datacontract_toObject(this.__wbg_ptr, platformVersion);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {object}
+     */
+    get tokens() {
+        const ret = wasm.datacontract_tokens(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.datacontract_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 version() {
+        const ret = wasm.datacontract_version(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DataContract.prototype[Symbol.dispose] = DataContract.prototype.free;
+
+export class DataContractCreateTransition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DataContractCreateTransition.prototype);
         obj.__wbg_ptr = ptr;
         DataContractCreateTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
@@ -5903,6 +6620,158 @@ export class Document {
 }
 if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
 
+/**
+ * What a document transition agrees to pay in document action fees. The amounts are the ones
+ * the document type declares for the action, read off the contract by the signer.
+ */
+export class DocumentActionFeeAgreement {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DocumentActionFeeAgreement.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentActionFeeAgreementFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocumentActionFeeAgreementFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_documentactionfeeagreement_free(ptr, 0);
+    }
+    /**
+     * @param {DocumentActionFeeAgreementOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.documentactionfeeagreement_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        DocumentActionFeeAgreementFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    get feeMultiplierIncreaseTolerancePercent() {
+        const ret = wasm.documentactionfeeagreement_fee_multiplier_increase_tolerance_percent(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret;
+    }
+    /**
+     * @param {DocumentActionFeeAgreementJSON} js
+     * @returns {DocumentActionFeeAgreement}
+     */
+    static fromJSON(js) {
+        const ret = wasm.documentactionfeeagreement_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DocumentActionFeeAgreement.__wrap(ret[0]);
+    }
+    /**
+     * @param {DocumentActionFeeAgreementObject} obj
+     * @returns {DocumentActionFeeAgreement}
+     */
+    static fromObject(obj) {
+        const ret = wasm.documentactionfeeagreement_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DocumentActionFeeAgreement.__wrap(ret[0]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get knownFeeMultiplierPermille() {
+        const ret = wasm.documentactionfeeagreement_known_fee_multiplier_permille(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get moderators() {
+        const ret = wasm.documentactionfeeagreement_moderators(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get owner() {
+        const ret = wasm.documentactionfeeagreement_owner(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get pricing() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.documentactionfeeagreement_pricing(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 {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.documentactionfeeagreement_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 {DocumentActionFeeAgreementJSON}
+     */
+    toJSON() {
+        const ret = wasm.documentactionfeeagreement_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {DocumentActionFeeAgreementObject}
+     */
+    toObject() {
+        const ret = wasm.documentactionfeeagreement_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.documentactionfeeagreement_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);
+        }
+    }
+}
+if (Symbol.dispose) DocumentActionFeeAgreement.prototype[Symbol.dispose] = DocumentActionFeeAgreement.prototype.free;
+
 export class DocumentBaseTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -5921,6 +6790,15 @@ export class DocumentBaseTransition {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_documentbasetransition_free(ptr, 0);
     }
+    /**
+     * The action fees this transition agrees to pay. A base older than version 2, which a
+     * transition decoded from the wire can carry, has none.
+     * @returns {DocumentActionFeeAgreement | undefined}
+     */
+    get actionFeeAgreement() {
+        const ret = wasm.documentbasetransition_action_fee_agreement(this.__wbg_ptr);
+        return ret === 0 ? undefined : DocumentActionFeeAgreement.__wrap(ret);
+    }
     /**
      * @param {DocumentBaseTransitionOptions} options
      */
@@ -5969,6 +6847,21 @@ export class DocumentBaseTransition {
         const ret = wasm.documentbasetransition_identity_contract_nonce(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Sets the action fees this transition agrees to pay, `undefined` clears them.
+     *
+     * Only a base of version 2 carries an agreement, so an older base, which the constructor
+     * builds when it is given none, is rebuilt as version 2 to take one.
+     * @param {DocumentActionFeeAgreement | null} [actionFeeAgreement]
+     */
+    set actionFeeAgreement(actionFeeAgreement) {
+        let ptr0 = 0;
+        if (!isLikeNone(actionFeeAgreement)) {
+            _assertClass(actionFeeAgreement, DocumentActionFeeAgreement);
+            ptr0 = actionFeeAgreement.__destroy_into_raw();
+        }
+        wasm.documentbasetransition_set_action_fee_agreement(this.__wbg_ptr, ptr0);
+    }
     /**
      * @param {IdentifierLike} data_contract_id
      */
@@ -6477,23 +7370,25 @@ if (Symbol.dispose) DocumentPurchaseTransition.prototype[Symbol.dispose] = Docum
  *   }
  * }
  * ```
- * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125}
+ * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125 | 40131}
  */
 export const DocumentReferenceErrorCode = Object.freeze({
     /**
-     * The referenced identity, contract, token or permanent document does
-     * not exist.
+     * The referenced identity, contract, token or document (permanent or
+     * deletable) does not exist.
      */
     ReferencedEntityNotFound: 40120, "40120": "ReferencedEntityNotFound",
     /**
-     * A `permanentDocument` reference names a document type the referenced
-     * contract does not define, or the contract itself is missing.
+     * A `permanentDocument` or `deletableDocument` reference names a
+     * document type the referenced contract does not define, or the
+     * contract itself is missing.
      */
     ReferencedDocumentTypeNotFound: 40121, "40121": "ReferencedDocumentTypeNotFound",
     /**
      * The referenced document type allows deletion. Only types declaring
      * `canBeDeleted: false` may be the target of a `permanentDocument`
-     * reference — otherwise the reference could be left dangling.
+     * reference — otherwise the reference could be left dangling. A
+     * `deletableDocument` reference is the one for such a type.
      */
     ReferencedDocumentTypeDeletable: 40122, "40122": "ReferencedDocumentTypeDeletable",
     /**
@@ -6509,6 +7404,13 @@ export const DocumentReferenceErrorCode = Object.freeze({
      * or names a property that is not an integer.
      */
     ReferencedKeyIdPropertyInvalid: 40125, "40125": "ReferencedKeyIdPropertyInvalid",
+    /**
+     * The referenced document type forbids deletion. Only types whose
+     * documents can be deleted may be the target of a `deletableDocument`
+     * reference; a `permanentDocument` reference is the one for a type
+     * declaring `canBeDeleted: false`.
+     */
+    ReferencedDocumentTypeNotDeletable: 40131, "40131": "ReferencedDocumentTypeNotDeletable",
 });
 
 export class DocumentReplaceTransition {
@@ -19629,6 +20531,13 @@ export class TokenDistributionRules {
         const ret = wasm.tokendistributionrules_new_tokens_destination_identity_rules(this.__wbg_ptr);
         return ChangeControlRules.__wrap(ret);
     }
+    /**
+     * @returns {TokenOncePerIdentityDistribution | undefined}
+     */
+    get oncePerIdentityDistribution() {
+        const ret = wasm.tokendistributionrules_once_per_identity_distribution(this.__wbg_ptr);
+        return ret === 0 ? undefined : TokenOncePerIdentityDistribution.__wrap(ret);
+    }
     /**
      * @returns {TokenPerpetualDistribution | undefined}
      */
@@ -19686,6 +20595,15 @@ export class TokenDistributionRules {
         _assertClass(rules, ChangeControlRules);
         wasm.tokendistributionrules_set_new_tokens_destination_identity_rules(this.__wbg_ptr, rules.__wbg_ptr);
     }
+    /**
+     * @param {any} distribution
+     */
+    set oncePerIdentityDistribution(distribution) {
+        const ret = wasm.tokendistributionrules_set_once_per_identity_distribution(this.__wbg_ptr, distribution);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {any} perpetual_distribution
      */
@@ -19745,11 +20663,12 @@ export class TokenDistributionRules {
 if (Symbol.dispose) TokenDistributionRules.prototype[Symbol.dispose] = TokenDistributionRules.prototype.free;
 
 /**
- * @enum {0 | 1}
+ * @enum {0 | 1 | 2}
  */
 export const TokenDistributionType = Object.freeze({
     PreProgrammed: 0, "0": "PreProgrammed",
     Perpetual: 1, "1": "Perpetual",
+    OncePerIdentity: 2, "2": "OncePerIdentity",
 });
 
 /**
@@ -20459,7 +21378,90 @@ export class TokenMintTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokenminttransition_struct_name();
+            const ret = wasm.tokenminttransition_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}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokenminttransition_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);
+        }
+    }
+}
+if (Symbol.dispose) TokenMintTransition.prototype[Symbol.dispose] = TokenMintTransition.prototype.free;
+
+/**
+ * A distribution every identity may claim exactly once: a fixed `amount` minted to the claimant
+ * on its first claim of type `OncePerIdentity`. Bounded only by the token's max supply.
+ */
+export class TokenOncePerIdentityDistribution {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TokenOncePerIdentityDistribution.prototype);
+        obj.__wbg_ptr = ptr;
+        TokenOncePerIdentityDistributionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TokenOncePerIdentityDistributionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tokenonceperidentitydistribution_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get amount() {
+        const ret = wasm.tokenonceperidentitydistribution_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {any} amount
+     */
+    constructor(amount) {
+        const ret = wasm.tokenonceperidentitydistribution_constructor(amount);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TokenOncePerIdentityDistributionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} amount
+     */
+    set amount(amount) {
+        const ret = wasm.tokenonceperidentitydistribution_set_amount(this.__wbg_ptr, amount);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokenonceperidentitydistribution_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -20474,7 +21476,7 @@ export class TokenMintTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokenminttransition_type_name(this.__wbg_ptr);
+            const ret = wasm.tokenonceperidentitydistribution_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -20483,7 +21485,7 @@ export class TokenMintTransition {
         }
     }
 }
-if (Symbol.dispose) TokenMintTransition.prototype[Symbol.dispose] = TokenMintTransition.prototype.free;
+if (Symbol.dispose) TokenOncePerIdentityDistribution.prototype[Symbol.dispose] = TokenOncePerIdentityDistribution.prototype.free;
 
 export class TokenPaymentInfo {
     static __wrap(ptr) {
@@ -20979,52 +21981,306 @@ if (Symbol.dispose) TokenPricingSchedule.prototype[Symbol.dispose] = TokenPricin
 export class TokenSetPriceForDirectPurchaseTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(TokenSetPriceForDirectPurchaseTransition.prototype);
+        const obj = Object.create(TokenSetPriceForDirectPurchaseTransition.prototype);
+        obj.__wbg_ptr = ptr;
+        TokenSetPriceForDirectPurchaseTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TokenSetPriceForDirectPurchaseTransitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tokensetpricefordirectpurchasetransition_free(ptr, 0);
+    }
+    /**
+     * @returns {TokenBaseTransition}
+     */
+    get base() {
+        const ret = wasm.tokensetpricefordirectpurchasetransition_base(this.__wbg_ptr);
+        return TokenBaseTransition.__wrap(ret);
+    }
+    /**
+     * @param {TokenSetPriceForDirectPurchaseTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.tokensetpricefordirectpurchasetransition_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TokenSetPriceForDirectPurchaseTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {TokenPricingSchedule | undefined}
+     */
+    get price() {
+        const ret = wasm.tokensetpricefordirectpurchasetransition_price(this.__wbg_ptr);
+        return ret === 0 ? undefined : TokenPricingSchedule.__wrap(ret);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get publicNote() {
+        const ret = wasm.tokensetpricefordirectpurchasetransition_public_note(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {TokenBaseTransition} base
+     */
+    set base(base) {
+        _assertClass(base, TokenBaseTransition);
+        var ptr0 = base.__destroy_into_raw();
+        wasm.tokensetpricefordirectpurchasetransition_set_base(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {TokenPricingSchedule | null} [price]
+     */
+    set price(price) {
+        let ptr0 = 0;
+        if (!isLikeNone(price)) {
+            _assertClass(price, TokenPricingSchedule);
+            ptr0 = price.__destroy_into_raw();
+        }
+        wasm.tokensetpricefordirectpurchasetransition_set_price(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {string | null} [note]
+     */
+    set publicNote(note) {
+        var ptr0 = isLikeNone(note) ? 0 : passStringToWasm0(note, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.tokensetpricefordirectpurchasetransition_set_public_note(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokensetpricefordirectpurchasetransition_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}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokensetpricefordirectpurchasetransition_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);
+        }
+    }
+}
+if (Symbol.dispose) TokenSetPriceForDirectPurchaseTransition.prototype[Symbol.dispose] = TokenSetPriceForDirectPurchaseTransition.prototype.free;
+
+export class TokenStatus {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TokenStatus.prototype);
+        obj.__wbg_ptr = ptr;
+        TokenStatusFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TokenStatusFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tokenstatus_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get isPaused() {
+        const ret = wasm.tokenstatus_is_paused(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokenstatus_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}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokenstatus_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);
+        }
+    }
+}
+if (Symbol.dispose) TokenStatus.prototype[Symbol.dispose] = TokenStatus.prototype.free;
+
+export class TokenTradeMode {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TokenTradeMode.prototype);
+        obj.__wbg_ptr = ptr;
+        TokenTradeModeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TokenTradeModeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tokentrademode_free(ptr, 0);
+    }
+    /**
+     * @returns {TokenTradeMode}
+     */
+    static NotTradeable() {
+        const ret = wasm.tokentrademode_NotTradeable();
+        return TokenTradeMode.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokentrademode_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}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokentrademode_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 {string}
+     */
+    get value() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tokentrademode_value(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);
+        }
+    }
+}
+if (Symbol.dispose) TokenTradeMode.prototype[Symbol.dispose] = TokenTradeMode.prototype.free;
+
+export class TokenTransferTransition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TokenTransferTransition.prototype);
         obj.__wbg_ptr = ptr;
-        TokenSetPriceForDirectPurchaseTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        TokenTransferTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TokenSetPriceForDirectPurchaseTransitionFinalization.unregister(this);
+        TokenTransferTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tokensetpricefordirectpurchasetransition_free(ptr, 0);
+        wasm.__wbg_tokentransfertransition_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get amount() {
+        const ret = wasm.tokentransfertransition_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
      * @returns {TokenBaseTransition}
      */
     get base() {
-        const ret = wasm.tokensetpricefordirectpurchasetransition_base(this.__wbg_ptr);
+        const ret = wasm.tokentransfertransition_base(this.__wbg_ptr);
         return TokenBaseTransition.__wrap(ret);
     }
     /**
-     * @param {TokenSetPriceForDirectPurchaseTransitionOptions} options
+     * @param {TokenTransferTransitionOptions} options
      */
     constructor(options) {
-        const ret = wasm.tokensetpricefordirectpurchasetransition_constructor(options);
+        const ret = wasm.tokentransfertransition_constructor(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        TokenSetPriceForDirectPurchaseTransitionFinalization.register(this, this.__wbg_ptr, this);
+        TokenTransferTransitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * @returns {TokenPricingSchedule | undefined}
+     * @returns {PrivateEncryptedNote | undefined}
      */
-    get price() {
-        const ret = wasm.tokensetpricefordirectpurchasetransition_price(this.__wbg_ptr);
-        return ret === 0 ? undefined : TokenPricingSchedule.__wrap(ret);
+    get privateEncryptedNote() {
+        const ret = wasm.tokentransfertransition_private_encrypted_note(this.__wbg_ptr);
+        return ret === 0 ? undefined : PrivateEncryptedNote.__wrap(ret);
     }
     /**
      * @returns {string | undefined}
      */
     get publicNote() {
-        const ret = wasm.tokensetpricefordirectpurchasetransition_public_note(this.__wbg_ptr);
+        const ret = wasm.tokentransfertransition_public_note(this.__wbg_ptr);
         let v1;
         if (ret[0] !== 0) {
             v1 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -21032,24 +22288,38 @@ export class TokenSetPriceForDirectPurchaseTransition {
         }
         return v1;
     }
+    /**
+     * @returns {Identifier}
+     */
+    get recipientId() {
+        const ret = wasm.tokentransfertransition_recipient_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @param {bigint} amount
+     */
+    set amount(amount) {
+        const ret = wasm.tokentransfertransition_set_amount(this.__wbg_ptr, amount);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {TokenBaseTransition} base
      */
     set base(base) {
         _assertClass(base, TokenBaseTransition);
         var ptr0 = base.__destroy_into_raw();
-        wasm.tokensetpricefordirectpurchasetransition_set_base(this.__wbg_ptr, ptr0);
+        wasm.tokentransfertransition_set_base(this.__wbg_ptr, ptr0);
     }
     /**
-     * @param {TokenPricingSchedule | null} [price]
+     * @param {any} privateEncryptedNote
      */
-    set price(price) {
-        let ptr0 = 0;
-        if (!isLikeNone(price)) {
-            _assertClass(price, TokenPricingSchedule);
-            ptr0 = price.__destroy_into_raw();
+    set privateEncryptedNote(privateEncryptedNote) {
+        const ret = wasm.tokentransfertransition_set_private_encrypted_note(this.__wbg_ptr, privateEncryptedNote);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
-        wasm.tokensetpricefordirectpurchasetransition_set_price(this.__wbg_ptr, ptr0);
     }
     /**
      * @param {string | null} [note]
@@ -21057,7 +22327,32 @@ export class TokenSetPriceForDirectPurchaseTransition {
     set publicNote(note) {
         var ptr0 = isLikeNone(note) ? 0 : passStringToWasm0(note, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        wasm.tokensetpricefordirectpurchasetransition_set_public_note(this.__wbg_ptr, ptr0, len0);
+        wasm.tokentransfertransition_set_public_note(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {IdentifierLike} recipientId
+     */
+    set recipientId(recipientId) {
+        const ret = wasm.tokentransfertransition_set_recipient_id(this.__wbg_ptr, recipientId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} sharedEncryptedNote
+     */
+    set sharedEncryptedNote(sharedEncryptedNote) {
+        const ret = wasm.tokentransfertransition_set_shared_encrypted_note(this.__wbg_ptr, sharedEncryptedNote);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {SharedEncryptedNote | undefined}
+     */
+    get sharedEncryptedNote() {
+        const ret = wasm.tokentransfertransition_shared_encrypted_note(this.__wbg_ptr);
+        return ret === 0 ? undefined : SharedEncryptedNote.__wrap(ret);
     }
     /**
      * @returns {string}
@@ -21066,7 +22361,7 @@ export class TokenSetPriceForDirectPurchaseTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokensetpricefordirectpurchasetransition_struct_name();
+            const ret = wasm.tokentransfertransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21081,7 +22376,7 @@ export class TokenSetPriceForDirectPurchaseTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokensetpricefordirectpurchasetransition_type_name(this.__wbg_ptr);
+            const ret = wasm.tokentransfertransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21090,56 +22385,64 @@ export class TokenSetPriceForDirectPurchaseTransition {
         }
     }
 }
-if (Symbol.dispose) TokenSetPriceForDirectPurchaseTransition.prototype[Symbol.dispose] = TokenSetPriceForDirectPurchaseTransition.prototype.free;
+if (Symbol.dispose) TokenTransferTransition.prototype[Symbol.dispose] = TokenTransferTransition.prototype.free;
 
-export class TokenStatus {
+export class TokenTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(TokenStatus.prototype);
+        const obj = Object.create(TokenTransition.prototype);
         obj.__wbg_ptr = ptr;
-        TokenStatusFinalization.register(obj, obj.__wbg_ptr, obj);
+        TokenTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TokenStatusFinalization.unregister(this);
+        TokenTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tokenstatus_free(ptr, 0);
+        wasm.__wbg_tokentransition_free(ptr, 0);
     }
     /**
-     * @returns {boolean}
+     * @param {TokenTransitionLike} transition
      */
-    get isPaused() {
-        const ret = wasm.tokenstatus_is_paused(this.__wbg_ptr);
-        return ret !== 0;
+    constructor(transition) {
+        const ret = wasm.tokentransition_constructor(transition);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TokenTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * @returns {string}
+     * @returns {Identifier}
      */
-    static get __struct() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.tokenstatus_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);
+    get contractId() {
+        const ret = wasm.tokentransition_contract_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @param {IdentifierLike} owner
+     * @returns {Identifier}
+     */
+    getHistoricalDocumentId(owner) {
+        const ret = wasm.tokentransition_getHistoricalDocumentId(this.__wbg_ptr, owner);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return Identifier.__wrap(ret[0]);
     }
     /**
      * @returns {string}
      */
-    get __type() {
+    get historicalDocumentTypeName() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokenstatus_type_name(this.__wbg_ptr);
+            const ret = wasm.tokentransition_historical_document_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21147,33 +22450,39 @@ export class TokenStatus {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-}
-if (Symbol.dispose) TokenStatus.prototype[Symbol.dispose] = TokenStatus.prototype.free;
-
-export class TokenTradeMode {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(TokenTradeMode.prototype);
-        obj.__wbg_ptr = ptr;
-        TokenTradeModeFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    /**
+     * @returns {bigint}
+     */
+    get identityContractNonce() {
+        const ret = wasm.tokentransition_identity_contract_nonce(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TokenTradeModeFinalization.unregister(this);
-        return ptr;
+    /**
+     * @param {IdentifierLike} contractId
+     */
+    set contractId(contractId) {
+        const ret = wasm.tokentransition_set_contract_id(this.__wbg_ptr, contractId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tokentrademode_free(ptr, 0);
+    /**
+     * @param {bigint} nonce
+     */
+    set identityContractNonce(nonce) {
+        const ret = wasm.tokentransition_set_identity_contract_nonce(this.__wbg_ptr, nonce);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * @returns {TokenTradeMode}
+     * @param {IdentifierLike} tokenId
      */
-    static NotTradeable() {
-        const ret = wasm.tokentrademode_NotTradeable();
-        return TokenTradeMode.__wrap(ret);
+    set tokenId(tokenId) {
+        const ret = wasm.tokentransition_set_token_id(this.__wbg_ptr, tokenId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
      * @returns {string}
@@ -21182,7 +22491,7 @@ export class TokenTradeMode {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentrademode_struct_name();
+            const ret = wasm.tokentransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21190,14 +22499,28 @@ export class TokenTradeMode {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {Identifier}
+     */
+    get tokenId() {
+        const ret = wasm.tokentransition_token_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {TokenTransitionLike}
+     */
+    get transition() {
+        const ret = wasm.tokentransition_transition(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {string}
      */
-    get __type() {
+    get transitionType() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentrademode_type_name(this.__wbg_ptr);
+            const ret = wasm.tokentransition_transition_type(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21205,14 +22528,21 @@ export class TokenTradeMode {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {number}
+     */
+    get transitionTypeNumber() {
+        const ret = wasm.tokentransition_transition_type_number(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {string}
      */
-    get value() {
+    get __type() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentrademode_value(this.__wbg_ptr);
+            const ret = wasm.tokentransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21221,64 +22551,57 @@ export class TokenTradeMode {
         }
     }
 }
-if (Symbol.dispose) TokenTradeMode.prototype[Symbol.dispose] = TokenTradeMode.prototype.free;
+if (Symbol.dispose) TokenTransition.prototype[Symbol.dispose] = TokenTransition.prototype.free;
 
-export class TokenTransferTransition {
+export class TokenUnFreezeTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(TokenTransferTransition.prototype);
+        const obj = Object.create(TokenUnFreezeTransition.prototype);
         obj.__wbg_ptr = ptr;
-        TokenTransferTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        TokenUnFreezeTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TokenTransferTransitionFinalization.unregister(this);
+        TokenUnFreezeTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tokentransfertransition_free(ptr, 0);
-    }
-    /**
-     * @returns {bigint}
-     */
-    get amount() {
-        const ret = wasm.tokentransfertransition_amount(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+        wasm.__wbg_tokenunfreezetransition_free(ptr, 0);
     }
     /**
      * @returns {TokenBaseTransition}
      */
     get base() {
-        const ret = wasm.tokentransfertransition_base(this.__wbg_ptr);
+        const ret = wasm.tokenunfreezetransition_base(this.__wbg_ptr);
         return TokenBaseTransition.__wrap(ret);
     }
     /**
-     * @param {TokenTransferTransitionOptions} options
+     * @param {TokenUnFreezeTransitionOptions} options
      */
     constructor(options) {
-        const ret = wasm.tokentransfertransition_constructor(options);
+        const ret = wasm.tokenunfreezetransition_constructor(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        TokenTransferTransitionFinalization.register(this, this.__wbg_ptr, this);
+        TokenUnFreezeTransitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * @returns {PrivateEncryptedNote | undefined}
+     * @returns {Identifier}
      */
-    get privateEncryptedNote() {
-        const ret = wasm.tokentransfertransition_private_encrypted_note(this.__wbg_ptr);
-        return ret === 0 ? undefined : PrivateEncryptedNote.__wrap(ret);
+    get frozenIdentityId() {
+        const ret = wasm.tokenunfreezetransition_frozen_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
      * @returns {string | undefined}
      */
     get publicNote() {
-        const ret = wasm.tokentransfertransition_public_note(this.__wbg_ptr);
+        const ret = wasm.tokenunfreezetransition_public_note(this.__wbg_ptr);
         let v1;
         if (ret[0] !== 0) {
             v1 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -21286,35 +22609,19 @@ export class TokenTransferTransition {
         }
         return v1;
     }
-    /**
-     * @returns {Identifier}
-     */
-    get recipientId() {
-        const ret = wasm.tokentransfertransition_recipient_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
-    }
-    /**
-     * @param {bigint} amount
-     */
-    set amount(amount) {
-        const ret = wasm.tokentransfertransition_set_amount(this.__wbg_ptr, amount);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
     /**
      * @param {TokenBaseTransition} base
      */
     set base(base) {
         _assertClass(base, TokenBaseTransition);
         var ptr0 = base.__destroy_into_raw();
-        wasm.tokentransfertransition_set_base(this.__wbg_ptr, ptr0);
+        wasm.tokenunfreezetransition_set_base(this.__wbg_ptr, ptr0);
     }
     /**
-     * @param {any} privateEncryptedNote
+     * @param {IdentifierLike} frozenIdentityId
      */
-    set privateEncryptedNote(privateEncryptedNote) {
-        const ret = wasm.tokentransfertransition_set_private_encrypted_note(this.__wbg_ptr, privateEncryptedNote);
+    set frozenIdentityId(frozenIdentityId) {
+        const ret = wasm.tokenunfreezetransition_set_frozen_identity_id(this.__wbg_ptr, frozenIdentityId);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -21325,32 +22632,7 @@ export class TokenTransferTransition {
     set publicNote(note) {
         var ptr0 = isLikeNone(note) ? 0 : passStringToWasm0(note, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        wasm.tokentransfertransition_set_public_note(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @param {IdentifierLike} recipientId
-     */
-    set recipientId(recipientId) {
-        const ret = wasm.tokentransfertransition_set_recipient_id(this.__wbg_ptr, recipientId);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @param {any} sharedEncryptedNote
-     */
-    set sharedEncryptedNote(sharedEncryptedNote) {
-        const ret = wasm.tokentransfertransition_set_shared_encrypted_note(this.__wbg_ptr, sharedEncryptedNote);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * @returns {SharedEncryptedNote | undefined}
-     */
-    get sharedEncryptedNote() {
-        const ret = wasm.tokentransfertransition_shared_encrypted_note(this.__wbg_ptr);
-        return ret === 0 ? undefined : SharedEncryptedNote.__wrap(ret);
+        wasm.tokenunfreezetransition_set_public_note(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @returns {string}
@@ -21359,7 +22641,7 @@ export class TokenTransferTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentransfertransition_struct_name();
+            const ret = wasm.tokenunfreezetransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21374,7 +22656,7 @@ export class TokenTransferTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentransfertransition_type_name(this.__wbg_ptr);
+            const ret = wasm.tokenunfreezetransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21383,64 +22665,192 @@ export class TokenTransferTransition {
         }
     }
 }
-if (Symbol.dispose) TokenTransferTransition.prototype[Symbol.dispose] = TokenTransferTransition.prototype.free;
+if (Symbol.dispose) TokenUnFreezeTransition.prototype[Symbol.dispose] = TokenUnFreezeTransition.prototype.free;
 
-export class TokenTransition {
+export class UnshieldTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(TokenTransition.prototype);
+        const obj = Object.create(UnshieldTransition.prototype);
         obj.__wbg_ptr = ptr;
-        TokenTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        UnshieldTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TokenTransitionFinalization.unregister(this);
+        UnshieldTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tokentransition_free(ptr, 0);
+        wasm.__wbg_unshieldtransition_free(ptr, 0);
     }
     /**
-     * @param {TokenTransitionLike} transition
+     * Returns the serialized Orchard actions.
+     * @returns {SerializedOrchardAction[]}
      */
-    constructor(transition) {
-        const ret = wasm.tokentransition_constructor(transition);
+    get actions() {
+        const ret = wasm.unshieldtransition_actions(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns the anchor (32-byte Merkle root).
+     * @returns {Uint8Array}
+     */
+    get anchor() {
+        const ret = wasm.unshieldtransition_anchor(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns the RedPallas binding signature (64 bytes).
+     * @returns {Uint8Array}
+     */
+    get bindingSignature() {
+        const ret = wasm.unshieldtransition_binding_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {UnshieldTransition}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.unshieldtransition_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return UnshieldTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {UnshieldTransitionJSON} js
+     * @returns {UnshieldTransition}
+     */
+    static fromJSON(js) {
+        const ret = wasm.unshieldtransition_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return UnshieldTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {UnshieldTransitionObject} obj
+     * @returns {UnshieldTransition}
+     */
+    static fromObject(obj) {
+        const ret = wasm.unshieldtransition_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return UnshieldTransition.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Identifier[]}
+     */
+    getModifiedDataIds() {
+        const ret = wasm.unshieldtransition_getModifiedDataIds(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {UnshieldTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.unshieldtransition_new(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        TokenTransitionFinalization.register(this, this.__wbg_ptr, this);
+        UnshieldTransitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * @returns {Identifier}
+     * Returns the output address receiving the unshielded funds.
+     * @returns {PlatformAddress}
      */
-    get contractId() {
-        const ret = wasm.tokentransition_contract_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+    get outputAddress() {
+        const ret = wasm.unshieldtransition_output_address(this.__wbg_ptr);
+        return PlatformAddress.__wrap(ret);
     }
     /**
-     * @param {IdentifierLike} owner
-     * @returns {Identifier}
+     * Returns the Halo2 proof bytes.
+     * @returns {Uint8Array}
      */
-    getHistoricalDocumentId(owner) {
-        const ret = wasm.tokentransition_getHistoricalDocumentId(this.__wbg_ptr, owner);
+    get proof() {
+        const ret = wasm.unshieldtransition_proof(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.unshieldtransition_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 {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.unshieldtransition_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 {UnshieldTransitionJSON}
+     */
+    toJSON() {
+        const ret = wasm.unshieldtransition_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return Identifier.__wrap(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {UnshieldTransitionObject}
+     */
+    toObject() {
+        const ret = wasm.unshieldtransition_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.unshieldtransition_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
     }
     /**
      * @returns {string}
      */
-    get historicalDocumentTypeName() {
+    get __type() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentransition_historical_document_type_name(this.__wbg_ptr);
+            const ret = wasm.unshieldtransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21449,38 +22859,62 @@ export class TokenTransition {
         }
     }
     /**
+     * Returns the unshielding amount.
      * @returns {bigint}
      */
-    get identityContractNonce() {
-        const ret = wasm.tokentransition_identity_contract_nonce(this.__wbg_ptr);
+    get unshieldingAmount() {
+        const ret = wasm.unshieldtransition_unshielding_amount(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+}
+if (Symbol.dispose) UnshieldTransition.prototype[Symbol.dispose] = UnshieldTransition.prototype.free;
+
+export class VerifiedAddressInfos {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VerifiedAddressInfos.prototype);
+        obj.__wbg_ptr = ptr;
+        VerifiedAddressInfosFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VerifiedAddressInfosFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_verifiedaddressinfos_free(ptr, 0);
+    }
     /**
-     * @param {IdentifierLike} contractId
+     * @returns {Map<any, any>}
      */
-    set contractId(contractId) {
-        const ret = wasm.tokentransition_set_contract_id(this.__wbg_ptr, contractId);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    get addressInfos() {
+        const ret = wasm.verifiedaddressinfos_address_infos(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {bigint} nonce
+     * @param {any} value
+     * @returns {VerifiedAddressInfos}
      */
-    set identityContractNonce(nonce) {
-        const ret = wasm.tokentransition_set_identity_contract_nonce(this.__wbg_ptr, nonce);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    static fromJSON(value) {
+        const ret = wasm.verifiedaddressinfos_fromJSON(value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return VerifiedAddressInfos.__wrap(ret[0]);
     }
     /**
-     * @param {IdentifierLike} tokenId
+     * @param {any} value
+     * @returns {VerifiedAddressInfos}
      */
-    set tokenId(tokenId) {
-        const ret = wasm.tokentransition_set_token_id(this.__wbg_ptr, tokenId);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    static fromObject(value) {
+        const ret = wasm.verifiedaddressinfos_fromObject(value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return VerifiedAddressInfos.__wrap(ret[0]);
     }
     /**
      * @returns {string}
@@ -21489,7 +22923,7 @@ export class TokenTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentransition_struct_name();
+            const ret = wasm.verifiedaddressinfos_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21498,39 +22932,23 @@ export class TokenTransition {
         }
     }
     /**
-     * @returns {Identifier}
-     */
-    get tokenId() {
-        const ret = wasm.tokentransition_token_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
-    }
-    /**
-     * @returns {TokenTransitionLike}
-     */
-    get transition() {
-        const ret = wasm.tokentransition_transition(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {string}
+     * Returns a `JSON.stringify`-friendly form: the `Map` is normalised to a
+     * plain object so its entries survive serialisation (otherwise
+     * `JSON.stringify({addressInfos: <Map>})` produces `{"addressInfos":{}}`).
+     * @returns {any}
      */
-    get transitionType() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.tokentransition_transition_type(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);
+    toJSON() {
+        const ret = wasm.verifiedaddressinfos_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {number}
+     * @returns {any}
      */
-    get transitionTypeNumber() {
-        const ret = wasm.tokentransition_transition_type_number(this.__wbg_ptr);
+    toObject() {
+        const ret = wasm.verifiedaddressinfos_toObject(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -21540,7 +22958,7 @@ export class TokenTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokentransition_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedaddressinfos_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21549,88 +22967,84 @@ export class TokenTransition {
         }
     }
 }
-if (Symbol.dispose) TokenTransition.prototype[Symbol.dispose] = TokenTransition.prototype.free;
+if (Symbol.dispose) VerifiedAddressInfos.prototype[Symbol.dispose] = VerifiedAddressInfos.prototype.free;
 
-export class TokenUnFreezeTransition {
+export class VerifiedAssetLockConsumed {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(TokenUnFreezeTransition.prototype);
+        const obj = Object.create(VerifiedAssetLockConsumed.prototype);
         obj.__wbg_ptr = ptr;
-        TokenUnFreezeTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        VerifiedAssetLockConsumedFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TokenUnFreezeTransitionFinalization.unregister(this);
+        VerifiedAssetLockConsumedFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tokenunfreezetransition_free(ptr, 0);
-    }
-    /**
-     * @returns {TokenBaseTransition}
-     */
-    get base() {
-        const ret = wasm.tokenunfreezetransition_base(this.__wbg_ptr);
-        return TokenBaseTransition.__wrap(ret);
+        wasm.__wbg_verifiedassetlockconsumed_free(ptr, 0);
     }
     /**
-     * @param {TokenUnFreezeTransitionOptions} options
+     * @returns {string}
      */
-    constructor(options) {
-        const ret = wasm.tokenunfreezetransition_constructor(options);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    get status() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_verifiedassetlockconsumed_status(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);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        TokenUnFreezeTransitionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
     }
     /**
-     * @returns {Identifier}
+     * @param {string} arg0
      */
-    get frozenIdentityId() {
-        const ret = wasm.tokenunfreezetransition_frozen_identity_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+    set status(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_verifiedassetlockconsumed_status(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @returns {string | undefined}
+     * @param {any} js
+     * @returns {VerifiedAssetLockConsumed}
      */
-    get publicNote() {
-        const ret = wasm.tokenunfreezetransition_public_note(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    static fromJSON(js) {
+        const ret = wasm.verifiedassetlockconsumed_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-        return v1;
+        return VerifiedAssetLockConsumed.__wrap(ret[0]);
     }
     /**
-     * @param {TokenBaseTransition} base
+     * @param {any} obj
+     * @returns {VerifiedAssetLockConsumed}
      */
-    set base(base) {
-        _assertClass(base, TokenBaseTransition);
-        var ptr0 = base.__destroy_into_raw();
-        wasm.tokenunfreezetransition_set_base(this.__wbg_ptr, ptr0);
+    static fromObject(obj) {
+        const ret = wasm.verifiedassetlockconsumed_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return VerifiedAssetLockConsumed.__wrap(ret[0]);
     }
     /**
-     * @param {IdentifierLike} frozenIdentityId
+     * @returns {any}
      */
-    set frozenIdentityId(frozenIdentityId) {
-        const ret = wasm.tokenunfreezetransition_set_frozen_identity_id(this.__wbg_ptr, frozenIdentityId);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    get initialCreditValue() {
+        const ret = wasm.verifiedassetlockconsumed_initialCreditValue(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {string | null} [note]
+     * @returns {any}
      */
-    set publicNote(note) {
-        var ptr0 = isLikeNone(note) ? 0 : passStringToWasm0(note, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        wasm.tokenunfreezetransition_set_public_note(this.__wbg_ptr, ptr0, len0);
+    get remainingCreditValue() {
+        const ret = wasm.verifiedassetlockconsumed_remainingCreditValue(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {string}
@@ -21639,7 +23053,7 @@ export class TokenUnFreezeTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokenunfreezetransition_struct_name();
+            const ret = wasm.verifiedassetlockconsumed_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21647,6 +23061,26 @@ export class TokenUnFreezeTransition {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.verifiedassetlockconsumed_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    toObject() {
+        const ret = wasm.verifiedassetlockconsumed_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @returns {string}
      */
@@ -21654,7 +23088,7 @@ export class TokenUnFreezeTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.tokenunfreezetransition_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedassetlockconsumed_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21663,138 +23097,77 @@ export class TokenUnFreezeTransition {
         }
     }
 }
-if (Symbol.dispose) TokenUnFreezeTransition.prototype[Symbol.dispose] = TokenUnFreezeTransition.prototype.free;
+if (Symbol.dispose) VerifiedAssetLockConsumed.prototype[Symbol.dispose] = VerifiedAssetLockConsumed.prototype.free;
 
-export class UnshieldTransition {
+export class VerifiedAssetLockConsumedWithAddressInfos {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(UnshieldTransition.prototype);
+        const obj = Object.create(VerifiedAssetLockConsumedWithAddressInfos.prototype);
         obj.__wbg_ptr = ptr;
-        UnshieldTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        VerifiedAssetLockConsumedWithAddressInfosFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        UnshieldTransitionFinalization.unregister(this);
+        VerifiedAssetLockConsumedWithAddressInfosFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_unshieldtransition_free(ptr, 0);
-    }
-    /**
-     * Returns the serialized Orchard actions.
-     * @returns {SerializedOrchardAction[]}
-     */
-    get actions() {
-        const ret = wasm.unshieldtransition_actions(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * Returns the anchor (32-byte Merkle root).
-     * @returns {Uint8Array}
-     */
-    get anchor() {
-        const ret = wasm.unshieldtransition_anchor(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Returns the RedPallas binding signature (64 bytes).
-     * @returns {Uint8Array}
-     */
-    get bindingSignature() {
-        const ret = wasm.unshieldtransition_binding_signature(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @param {Uint8Array} bytes
-     * @returns {UnshieldTransition}
-     */
-    static fromBytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.unshieldtransition_fromBytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return UnshieldTransition.__wrap(ret[0]);
+        wasm.__wbg_verifiedassetlockconsumedwithaddressinfos_free(ptr, 0);
     }
     /**
-     * @param {UnshieldTransitionJSON} js
-     * @returns {UnshieldTransition}
+     * @returns {Map<any, any>}
      */
-    static fromJSON(js) {
-        const ret = wasm.unshieldtransition_fromJSON(js);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return UnshieldTransition.__wrap(ret[0]);
+    get addressInfos() {
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_address_infos(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {UnshieldTransitionObject} obj
-     * @returns {UnshieldTransition}
+     * @param {any} value
+     * @returns {VerifiedAssetLockConsumedWithAddressInfos}
      */
-    static fromObject(obj) {
-        const ret = wasm.unshieldtransition_fromObject(obj);
+    static fromJSON(value) {
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_fromJSON(value);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return UnshieldTransition.__wrap(ret[0]);
-    }
-    /**
-     * @returns {Identifier[]}
-     */
-    getModifiedDataIds() {
-        const ret = wasm.unshieldtransition_getModifiedDataIds(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        return VerifiedAssetLockConsumedWithAddressInfos.__wrap(ret[0]);
     }
     /**
-     * @param {UnshieldTransitionOptions} options
+     * @param {any} value
+     * @returns {VerifiedAssetLockConsumedWithAddressInfos}
      */
-    constructor(options) {
-        const ret = wasm.unshieldtransition_new(options);
+    static fromObject(value) {
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_fromObject(value);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        UnshieldTransitionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        return VerifiedAssetLockConsumedWithAddressInfos.__wrap(ret[0]);
     }
     /**
-     * Returns the output address receiving the unshielded funds.
-     * @returns {PlatformAddress}
+     * @returns {any}
      */
-    get outputAddress() {
-        const ret = wasm.unshieldtransition_output_address(this.__wbg_ptr);
-        return PlatformAddress.__wrap(ret);
+    get initialCreditValue() {
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_initialCreditValue(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Returns the Halo2 proof bytes.
-     * @returns {Uint8Array}
+     * @returns {any}
      */
-    get proof() {
-        const ret = wasm.unshieldtransition_proof(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+    get remainingCreditValue() {
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_remainingCreditValue(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {string}
      */
-    static get __struct() {
+    get status() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.unshieldtransition_struct_name();
+            const ret = wasm.verifiedassetlockconsumedwithaddressinfos_status(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21803,43 +23176,38 @@ export class UnshieldTransition {
         }
     }
     /**
-     * @returns {Uint8Array}
+     * @returns {string}
      */
-    toBytes() {
-        const ret = wasm.unshieldtransition_toBytes(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.verifiedassetlockconsumedwithaddressinfos_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);
         }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
     }
     /**
-     * @returns {UnshieldTransitionJSON}
+     * Returns a `JSON.stringify`-friendly form: the `Map` is normalised to a
+     * plain object so its entries survive serialisation.
+     * @returns {any}
      */
     toJSON() {
-        const ret = wasm.unshieldtransition_toJSON(this.__wbg_ptr);
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {UnshieldTransitionObject}
+     * @returns {any}
      */
     toObject() {
-        const ret = wasm.unshieldtransition_toObject(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @returns {StateTransition}
-     */
-    toStateTransition() {
-        const ret = wasm.unshieldtransition_toStateTransition(this.__wbg_ptr);
-        return StateTransition.__wrap(ret);
+        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_toObject(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {string}
@@ -21848,7 +23216,7 @@ export class UnshieldTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.unshieldtransition_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedassetlockconsumedwithaddressinfos_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21856,63 +23224,78 @@ export class UnshieldTransition {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * Returns the unshielding amount.
-     * @returns {bigint}
-     */
-    get unshieldingAmount() {
-        const ret = wasm.unshieldtransition_unshielding_amount(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
 }
-if (Symbol.dispose) UnshieldTransition.prototype[Symbol.dispose] = UnshieldTransition.prototype.free;
+if (Symbol.dispose) VerifiedAssetLockConsumedWithAddressInfos.prototype[Symbol.dispose] = VerifiedAssetLockConsumedWithAddressInfos.prototype.free;
 
-export class VerifiedAddressInfos {
+export class VerifiedBalanceTransfer {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(VerifiedAddressInfos.prototype);
+        const obj = Object.create(VerifiedBalanceTransfer.prototype);
         obj.__wbg_ptr = ptr;
-        VerifiedAddressInfosFinalization.register(obj, obj.__wbg_ptr, obj);
+        VerifiedBalanceTransferFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        VerifiedAddressInfosFinalization.unregister(this);
+        VerifiedBalanceTransferFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_verifiedaddressinfos_free(ptr, 0);
+        wasm.__wbg_verifiedbalancetransfer_free(ptr, 0);
     }
     /**
-     * @returns {Map<any, any>}
+     * @returns {PartialIdentity}
      */
-    get addressInfos() {
-        const ret = wasm.verifiedaddressinfos_address_infos(this.__wbg_ptr);
-        return ret;
+    get recipient() {
+        const ret = wasm.__wbg_get_verifiedbalancetransfer_recipient(this.__wbg_ptr);
+        return PartialIdentity.__wrap(ret);
     }
     /**
-     * @param {any} value
-     * @returns {VerifiedAddressInfos}
+     * @returns {PartialIdentity}
      */
-    static fromJSON(value) {
-        const ret = wasm.verifiedaddressinfos_fromJSON(value);
+    get sender() {
+        const ret = wasm.__wbg_get_verifiedbalancetransfer_sender(this.__wbg_ptr);
+        return PartialIdentity.__wrap(ret);
+    }
+    /**
+     * @param {PartialIdentity} arg0
+     */
+    set recipient(arg0) {
+        _assertClass(arg0, PartialIdentity);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedbalancetransfer_recipient(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {PartialIdentity} arg0
+     */
+    set sender(arg0) {
+        _assertClass(arg0, PartialIdentity);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedbalancetransfer_sender(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @param {any} js
+     * @returns {VerifiedBalanceTransfer}
+     */
+    static fromJSON(js) {
+        const ret = wasm.verifiedbalancetransfer_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return VerifiedAddressInfos.__wrap(ret[0]);
+        return VerifiedBalanceTransfer.__wrap(ret[0]);
     }
     /**
-     * @param {any} value
-     * @returns {VerifiedAddressInfos}
+     * @param {any} obj
+     * @returns {VerifiedBalanceTransfer}
      */
-    static fromObject(value) {
-        const ret = wasm.verifiedaddressinfos_fromObject(value);
+    static fromObject(obj) {
+        const ret = wasm.verifiedbalancetransfer_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return VerifiedAddressInfos.__wrap(ret[0]);
+        return VerifiedBalanceTransfer.__wrap(ret[0]);
     }
     /**
      * @returns {string}
@@ -21921,7 +23304,7 @@ export class VerifiedAddressInfos {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedaddressinfos_struct_name();
+            const ret = wasm.verifiedbalancetransfer_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21930,13 +23313,10 @@ export class VerifiedAddressInfos {
         }
     }
     /**
-     * Returns a `JSON.stringify`-friendly form: the `Map` is normalised to a
-     * plain object so its entries survive serialisation (otherwise
-     * `JSON.stringify({addressInfos: <Map>})` produces `{"addressInfos":{}}`).
      * @returns {any}
      */
     toJSON() {
-        const ret = wasm.verifiedaddressinfos_toJSON(this.__wbg_ptr);
+        const ret = wasm.verifiedbalancetransfer_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -21946,8 +23326,11 @@ export class VerifiedAddressInfos {
      * @returns {any}
      */
     toObject() {
-        const ret = wasm.verifiedaddressinfos_toObject(this.__wbg_ptr);
-        return ret;
+        const ret = wasm.verifiedbalancetransfer_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * @returns {string}
@@ -21956,7 +23339,7 @@ export class VerifiedAddressInfos {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedaddressinfos_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedbalancetransfer_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -21965,83 +23348,132 @@ export class VerifiedAddressInfos {
         }
     }
 }
-if (Symbol.dispose) VerifiedAddressInfos.prototype[Symbol.dispose] = VerifiedAddressInfos.prototype.free;
+if (Symbol.dispose) VerifiedBalanceTransfer.prototype[Symbol.dispose] = VerifiedBalanceTransfer.prototype.free;
 
-export class VerifiedAssetLockConsumed {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(VerifiedAssetLockConsumed.prototype);
-        obj.__wbg_ptr = ptr;
-        VerifiedAssetLockConsumedFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+/**
+ * `VerifiedContractDocumentRemoval` proof-result wrapper: the record a moderator's document
+ * deletion left under the contract. The document itself is gone; the record says whose it
+ * was, who removed it, why and when.
+ */
+export class VerifiedContractDocumentRemoval {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        VerifiedAssetLockConsumedFinalization.unregister(this);
+        VerifiedContractDocumentRemovalFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_verifiedassetlockconsumed_free(ptr, 0);
+        wasm.__wbg_verifiedcontractdocumentremoval_free(ptr, 0);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get contractId() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_contractId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get documentId() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_documentId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * The identity that owned the document when it was removed
+     * @returns {Identifier}
+     */
+    get documentOwnerId() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_documentOwnerId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get documentTypeName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_documentTypeName(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);
+        }
+    }
+    /**
+     * The contract owner or moderator that removed it
+     * @returns {Identifier}
+     */
+    get moderatorId() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_moderatorId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * The time of the block that removed it, in milliseconds
+     * @returns {bigint}
+     */
+    get removedAt() {
+        const ret = wasm.__wbg_get_verifiedcontractdocumentremoval_removedAt(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {Identifier} arg0
+     */
+    set contractId(arg0) {
+        _assertClass(arg0, Identifier);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedcontractdocumentremoval_contractId(this.__wbg_ptr, ptr0);
     }
     /**
-     * @returns {string}
+     * @param {Identifier} arg0
      */
-    get status() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.__wbg_get_verifiedassetlockconsumed_status(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);
-        }
+    set documentId(arg0) {
+        _assertClass(arg0, Identifier);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedcontractdocumentremoval_documentId(this.__wbg_ptr, ptr0);
     }
     /**
-     * @param {string} arg0
+     * The identity that owned the document when it was removed
+     * @param {Identifier} arg0
      */
-    set status(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_verifiedassetlockconsumed_status(this.__wbg_ptr, ptr0, len0);
+    set documentOwnerId(arg0) {
+        _assertClass(arg0, Identifier);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedcontractdocumentremoval_documentOwnerId(this.__wbg_ptr, ptr0);
     }
     /**
-     * @param {any} js
-     * @returns {VerifiedAssetLockConsumed}
+     * @param {string} arg0
      */
-    static fromJSON(js) {
-        const ret = wasm.verifiedassetlockconsumed_fromJSON(js);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return VerifiedAssetLockConsumed.__wrap(ret[0]);
+    set documentTypeName(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_verifiedcontractdocumentremoval_documentTypeName(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {any} obj
-     * @returns {VerifiedAssetLockConsumed}
+     * The contract owner or moderator that removed it
+     * @param {Identifier} arg0
      */
-    static fromObject(obj) {
-        const ret = wasm.verifiedassetlockconsumed_fromObject(obj);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return VerifiedAssetLockConsumed.__wrap(ret[0]);
+    set moderatorId(arg0) {
+        _assertClass(arg0, Identifier);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedcontractdocumentremoval_moderatorId(this.__wbg_ptr, ptr0);
     }
     /**
-     * @returns {any}
+     * The time of the block that removed it, in milliseconds
+     * @param {bigint} arg0
      */
-    get initialCreditValue() {
-        const ret = wasm.verifiedassetlockconsumed_initialCreditValue(this.__wbg_ptr);
-        return ret;
+    set removedAt(arg0) {
+        wasm.__wbg_set_verifiedcontractdocumentremoval_removedAt(this.__wbg_ptr, arg0);
     }
     /**
-     * @returns {any}
+     * Why the moderator removed the document: the text may be empty
+     * @returns {ContractModerationReason}
      */
-    get remainingCreditValue() {
-        const ret = wasm.verifiedassetlockconsumed_remainingCreditValue(this.__wbg_ptr);
+    get reason() {
+        const ret = wasm.verifiedcontractdocumentremoval_reason(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -22051,7 +23483,7 @@ export class VerifiedAssetLockConsumed {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedassetlockconsumed_struct_name();
+            const ret = wasm.verifiedcontractdocumentremoval_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22063,7 +23495,7 @@ export class VerifiedAssetLockConsumed {
      * @returns {any}
      */
     toJSON() {
-        const ret = wasm.verifiedassetlockconsumed_toJSON(this.__wbg_ptr);
+        const ret = wasm.verifiedcontractdocumentremoval_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -22073,7 +23505,7 @@ export class VerifiedAssetLockConsumed {
      * @returns {any}
      */
     toObject() {
-        const ret = wasm.verifiedassetlockconsumed_toObject(this.__wbg_ptr);
+        const ret = wasm.verifiedcontractdocumentremoval_toObject(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -22086,7 +23518,7 @@ export class VerifiedAssetLockConsumed {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedassetlockconsumed_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedcontractdocumentremoval_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22095,77 +23527,59 @@ export class VerifiedAssetLockConsumed {
         }
     }
 }
-if (Symbol.dispose) VerifiedAssetLockConsumed.prototype[Symbol.dispose] = VerifiedAssetLockConsumed.prototype.free;
+if (Symbol.dispose) VerifiedContractDocumentRemoval.prototype[Symbol.dispose] = VerifiedContractDocumentRemoval.prototype.free;
 
-export class VerifiedAssetLockConsumedWithAddressInfos {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(VerifiedAssetLockConsumedWithAddressInfos.prototype);
-        obj.__wbg_ptr = ptr;
-        VerifiedAssetLockConsumedWithAddressInfosFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+/**
+ * `VerifiedContractFeeClaim` proof-result wrapper: the pot a contract fee claim paid out (the
+ * contract, the pot, its last claim, the credits left in it) and the balance of every identity
+ * the claim paid, after the claim. A pot is paid out at most once per epoch, so while
+ * `lastClaimEpoch` is the epoch of the claim the proof is of that claim, and `lastClaimantId`
+ * and `lastClaimTimeMs` are its own.
+ */
+export class VerifiedContractFeeClaim {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        VerifiedAssetLockConsumedWithAddressInfosFinalization.unregister(this);
+        VerifiedContractFeeClaimFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_verifiedassetlockconsumedwithaddressinfos_free(ptr, 0);
-    }
-    /**
-     * @returns {Map<any, any>}
-     */
-    get addressInfos() {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_address_infos(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {any} value
-     * @returns {VerifiedAssetLockConsumedWithAddressInfos}
-     */
-    static fromJSON(value) {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_fromJSON(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return VerifiedAssetLockConsumedWithAddressInfos.__wrap(ret[0]);
+        wasm.__wbg_verifiedcontractfeeclaim_free(ptr, 0);
     }
     /**
-     * @param {any} value
-     * @returns {VerifiedAssetLockConsumedWithAddressInfos}
+     * @returns {Identifier}
      */
-    static fromObject(value) {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_fromObject(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return VerifiedAssetLockConsumedWithAddressInfos.__wrap(ret[0]);
+    get contractId() {
+        const ret = wasm.__wbg_get_verifiedcontractfeeclaim_contractId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
-     * @returns {any}
+     * The epoch the pot was last claimed in: this claim's own, unless the pot was claimed
+     * again since
+     * @returns {number}
      */
-    get initialCreditValue() {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_initialCreditValue(this.__wbg_ptr);
+    get lastClaimEpoch() {
+        const ret = wasm.__wbg_get_verifiedcontractfeeclaim_lastClaimEpoch(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {any}
+     * The identity that signed the last claim of the pot
+     * @returns {Identifier}
      */
-    get remainingCreditValue() {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_remainingCreditValue(this.__wbg_ptr);
-        return ret;
+    get lastClaimantId() {
+        const ret = wasm.__wbg_get_verifiedcontractfeeclaim_lastClaimantId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
+     * The pot that was paid out: `owner` or `moderators`
      * @returns {string}
      */
-    get status() {
+    get pot() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedassetlockconsumedwithaddressinfos_status(this.__wbg_ptr);
+            const ret = wasm.__wbg_get_verifiedcontractfeeclaim_pot(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22173,6 +23587,64 @@ export class VerifiedAssetLockConsumedWithAddressInfos {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {Identifier} arg0
+     */
+    set contractId(arg0) {
+        _assertClass(arg0, Identifier);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedcontractfeeclaim_contractId(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * The epoch the pot was last claimed in: this claim's own, unless the pot was claimed
+     * again since
+     * @param {number} arg0
+     */
+    set lastClaimEpoch(arg0) {
+        wasm.__wbg_set_verifiedcontractfeeclaim_lastClaimEpoch(this.__wbg_ptr, arg0);
+    }
+    /**
+     * The identity that signed the last claim of the pot
+     * @param {Identifier} arg0
+     */
+    set lastClaimantId(arg0) {
+        _assertClass(arg0, Identifier);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_verifiedcontractfeeclaim_lastClaimantId(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * The pot that was paid out: `owner` or `moderators`
+     * @param {string} arg0
+     */
+    set pot(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_verifiedcontractfeeclaim_pot(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * The balance of every identity the claim paid, after the claim
+     * @returns {Map<any, any>}
+     */
+    get balances() {
+        const ret = wasm.verifiedcontractfeeclaim_balances(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The time, in milliseconds, of the block the pot was last paid out in
+     * @returns {any}
+     */
+    get lastClaimTimeMs() {
+        const ret = wasm.verifiedcontractfeeclaim_last_claim_time_ms(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The credits left in the pot after the claim
+     * @returns {any}
+     */
+    get remainingCredits() {
+        const ret = wasm.verifiedcontractfeeclaim_remaining_credits(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {string}
      */
@@ -22180,7 +23652,7 @@ export class VerifiedAssetLockConsumedWithAddressInfos {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedassetlockconsumedwithaddressinfos_struct_name();
+            const ret = wasm.verifiedcontractfeeclaim_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22189,12 +23661,13 @@ export class VerifiedAssetLockConsumedWithAddressInfos {
         }
     }
     /**
-     * Returns a `JSON.stringify`-friendly form: the `Map` is normalised to a
-     * plain object so its entries survive serialisation.
+     * Returns a `JSON.stringify`-friendly form: the `balances` `Map` is normalised to a plain
+     * object so its entries survive serialisation (otherwise `JSON.stringify({balances: <Map>})`
+     * produces `{"balances":{}}`).
      * @returns {any}
      */
     toJSON() {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_toJSON(this.__wbg_ptr);
+        const ret = wasm.verifiedcontractfeeclaim_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -22204,8 +23677,11 @@ export class VerifiedAssetLockConsumedWithAddressInfos {
      * @returns {any}
      */
     toObject() {
-        const ret = wasm.verifiedassetlockconsumedwithaddressinfos_toObject(this.__wbg_ptr);
-        return ret;
+        const ret = wasm.verifiedcontractfeeclaim_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * @returns {string}
@@ -22214,7 +23690,7 @@ export class VerifiedAssetLockConsumedWithAddressInfos {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedassetlockconsumedwithaddressinfos_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedcontractfeeclaim_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22223,77 +23699,113 @@ export class VerifiedAssetLockConsumedWithAddressInfos {
         }
     }
 }
-if (Symbol.dispose) VerifiedAssetLockConsumedWithAddressInfos.prototype[Symbol.dispose] = VerifiedAssetLockConsumedWithAddressInfos.prototype.free;
+if (Symbol.dispose) VerifiedContractFeeClaim.prototype[Symbol.dispose] = VerifiedContractFeeClaim.prototype.free;
 
-export class VerifiedBalanceTransfer {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(VerifiedBalanceTransfer.prototype);
-        obj.__wbg_ptr = ptr;
-        VerifiedBalanceTransferFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+/**
+ * `VerifiedContractModerationListStatuses` proof-result wrapper: the target identity's status
+ * on the lists a moderation transition touched (both for a ban, the edited one otherwise).
+ * A list the proof does not cover is unknown: `banned` is undefined unless `lists` includes
+ * `banlist`.
+ */
+export class VerifiedContractModerationListStatuses {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        VerifiedBalanceTransferFinalization.unregister(this);
+        VerifiedContractModerationListStatusesFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_verifiedbalancetransfer_free(ptr, 0);
+        wasm.__wbg_verifiedcontractmoderationliststatuses_free(ptr, 0);
     }
     /**
-     * @returns {PartialIdentity}
+     * When `lists` includes `banlist`: the identity is on the banlist
+     * @returns {boolean | undefined}
      */
-    get recipient() {
-        const ret = wasm.__wbg_get_verifiedbalancetransfer_recipient(this.__wbg_ptr);
-        return PartialIdentity.__wrap(ret);
+    get banned() {
+        const ret = wasm.__wbg_get_verifiedcontractmoderationliststatuses_banned(this.__wbg_ptr);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
     }
     /**
-     * @returns {PartialIdentity}
+     * @returns {Identifier}
      */
-    get sender() {
-        const ret = wasm.__wbg_get_verifiedbalancetransfer_sender(this.__wbg_ptr);
-        return PartialIdentity.__wrap(ret);
+    get contractId() {
+        const ret = wasm.__wbg_get_verifiedcontractmoderationliststatuses_contractId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
-     * @param {PartialIdentity} arg0
+     * @returns {Identifier}
      */
-    set recipient(arg0) {
-        _assertClass(arg0, PartialIdentity);
+    get identityId() {
+        const ret = wasm.__wbg_get_verifiedcontractmoderationliststatuses_identityId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * The lists the proof covers: `banlist`, `suspensions`, or both
+     * @returns {string[]}
+     */
+    get lists() {
+        const ret = wasm.__wbg_get_verifiedcontractmoderationliststatuses_lists(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * When `lists` includes `suspensions`: the block time, in milliseconds, until which the
+     * identity is suspended
+     * @returns {bigint | undefined}
+     */
+    get suspendedUntil() {
+        const ret = wasm.__wbg_get_verifiedcontractmoderationliststatuses_suspendedUntil(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * When `lists` includes `banlist`: the identity is on the banlist
+     * @param {boolean | null} [arg0]
+     */
+    set banned(arg0) {
+        wasm.__wbg_set_verifiedcontractmoderationliststatuses_banned(this.__wbg_ptr, isLikeNone(arg0) ? 0xFFFFFF : arg0 ? 1 : 0);
+    }
+    /**
+     * @param {Identifier} arg0
+     */
+    set contractId(arg0) {
+        _assertClass(arg0, Identifier);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedbalancetransfer_recipient(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedcontractdocumentremoval_documentId(this.__wbg_ptr, ptr0);
     }
     /**
-     * @param {PartialIdentity} arg0
+     * @param {Identifier} arg0
      */
-    set sender(arg0) {
-        _assertClass(arg0, PartialIdentity);
+    set identityId(arg0) {
+        _assertClass(arg0, Identifier);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedbalancetransfer_sender(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedcontractdocumentremoval_documentOwnerId(this.__wbg_ptr, ptr0);
     }
     /**
-     * @param {any} js
-     * @returns {VerifiedBalanceTransfer}
+     * The lists the proof covers: `banlist`, `suspensions`, or both
+     * @param {string[]} arg0
      */
-    static fromJSON(js) {
-        const ret = wasm.verifiedbalancetransfer_fromJSON(js);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return VerifiedBalanceTransfer.__wrap(ret[0]);
+    set lists(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_verifiedcontractmoderationliststatuses_lists(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {any} obj
-     * @returns {VerifiedBalanceTransfer}
+     * When `lists` includes `suspensions`: the block time, in milliseconds, until which the
+     * identity is suspended
+     * @param {bigint | null} [arg0]
      */
-    static fromObject(obj) {
-        const ret = wasm.verifiedbalancetransfer_fromObject(obj);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return VerifiedBalanceTransfer.__wrap(ret[0]);
+    set suspendedUntil(arg0) {
+        wasm.__wbg_set_verifiedcontractmoderationliststatuses_suspendedUntil(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
+    }
+    /**
+     * When the identity is banned: why
+     * @returns {ContractModerationReason | undefined}
+     */
+    get banReason() {
+        const ret = wasm.verifiedcontractmoderationliststatuses_ban_reason(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {string}
@@ -22302,7 +23814,7 @@ export class VerifiedBalanceTransfer {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedbalancetransfer_struct_name();
+            const ret = wasm.verifiedcontractmoderationliststatuses_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22310,11 +23822,19 @@ export class VerifiedBalanceTransfer {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * When the identity is suspended: why
+     * @returns {ContractModerationReason | undefined}
+     */
+    get suspensionReason() {
+        const ret = wasm.verifiedcontractmoderationliststatuses_suspension_reason(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {any}
      */
     toJSON() {
-        const ret = wasm.verifiedbalancetransfer_toJSON(this.__wbg_ptr);
+        const ret = wasm.verifiedcontractmoderationliststatuses_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -22324,7 +23844,7 @@ export class VerifiedBalanceTransfer {
      * @returns {any}
      */
     toObject() {
-        const ret = wasm.verifiedbalancetransfer_toObject(this.__wbg_ptr);
+        const ret = wasm.verifiedcontractmoderationliststatuses_toObject(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -22337,7 +23857,7 @@ export class VerifiedBalanceTransfer {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.verifiedbalancetransfer_type_name(this.__wbg_ptr);
+            const ret = wasm.verifiedcontractmoderationliststatuses_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -22346,7 +23866,7 @@ export class VerifiedBalanceTransfer {
         }
     }
 }
-if (Symbol.dispose) VerifiedBalanceTransfer.prototype[Symbol.dispose] = VerifiedBalanceTransfer.prototype.free;
+if (Symbol.dispose) VerifiedContractModerationListStatuses.prototype[Symbol.dispose] = VerifiedContractModerationListStatuses.prototype.free;
 
 export class VerifiedDataContract {
     static __wrap(ptr) {
@@ -22699,7 +24219,7 @@ export class VerifiedIdentityFullWithAddressInfos {
     set identity(arg0) {
         _assertClass(arg0, Identity);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedidentity_identity(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedidentityfullwithaddressinfos_identity(this.__wbg_ptr, ptr0);
     }
     /**
      * @returns {Map<any, any>}
@@ -22816,7 +24336,7 @@ export class VerifiedIdentityWithAddressInfos {
     set partialIdentity(arg0) {
         _assertClass(arg0, PartialIdentity);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedbalancetransfer_sender(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedidentitywithaddressinfos_partialIdentity(this.__wbg_ptr, ptr0);
     }
     /**
      * @returns {Map<any, any>}
@@ -26230,6 +27750,12 @@ const ContestedDocumentVotePollWinnerInfoFinalization = (typeof FinalizationRegi
 const ContractBoundsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_contractbounds_free(ptr >>> 0, 1));
+const ContractFeeClaimFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contractfeeclaim_free(ptr >>> 0, 1));
+const ContractUserModerationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contractusermoderation_free(ptr >>> 0, 1));
 const CoreScriptFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_corescript_free(ptr >>> 0, 1));
@@ -26272,6 +27798,9 @@ const DistributionStepDecreasingAmountFinalization = (typeof FinalizationRegistr
 const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));
+const DocumentActionFeeAgreementFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_documentactionfeeagreement_free(ptr >>> 0, 1));
 const DocumentBaseTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_documentbasetransition_free(ptr >>> 0, 1));
@@ -26509,6 +28038,9 @@ const TokenMarketplaceRulesFinalization = (typeof FinalizationRegistry === 'unde
 const TokenMintTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tokenminttransition_free(ptr >>> 0, 1));
+const TokenOncePerIdentityDistributionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tokenonceperidentitydistribution_free(ptr >>> 0, 1));
 const TokenPaymentInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tokenpaymentinfo_free(ptr >>> 0, 1));
@@ -26554,6 +28086,15 @@ const VerifiedAssetLockConsumedWithAddressInfosFinalization = (typeof Finalizati
 const VerifiedBalanceTransferFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verifiedbalancetransfer_free(ptr >>> 0, 1));
+const VerifiedContractDocumentRemovalFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_verifiedcontractdocumentremoval_free(ptr >>> 0, 1));
+const VerifiedContractFeeClaimFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_verifiedcontractfeeclaim_free(ptr >>> 0, 1));
+const VerifiedContractModerationListStatusesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_verifiedcontractmoderationliststatuses_free(ptr >>> 0, 1));
 const VerifiedDataContractFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_verifieddatacontract_free(ptr >>> 0, 1));