@dashevo/wasm-dpp2 4.2.0-dev.1 → 4.2.0-dev.11

package/dist/raw/wasm_dpp2.js

@@ -1859,7 +1859,7 @@ export class BatchTransition {
 if (Symbol.dispose) BatchTransition.prototype[Symbol.dispose] = BatchTransition.prototype.free;
 
 /**
- * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
  */
 export const BatchType = Object.freeze({
     Create: 0, "0": "Create",
@@ -1869,6 +1869,7 @@ export const BatchType = Object.freeze({
     Purchase: 4, "4": "Purchase",
     UpdatePrice: 5, "5": "UpdatePrice",
     IgnoreWhileBumpingRevision: 6, "6": "IgnoreWhileBumpingRevision",
+    IndexOnlyDelete: 7, "7": "IndexOnlyDelete",
 });
 
 export class BatchedTransition {
@@ -2493,6 +2494,18 @@ export class ConsensusError {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_consensuserror_free(ptr, 0);
     }
+    /**
+     * The consensus error code.
+     *
+     * This is the same number that reaches JS as `WasmSdkError.code` when
+     * a state transition is rejected. See [`DocumentReferenceErrorCodeWasm`]
+     * for the reference-validation range.
+     * @returns {number}
+     */
+    get code() {
+        const ret = wasm.consensuserror_code(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @param {Uint8Array} error
      * @returns {ConsensusError}
@@ -2506,6 +2519,15 @@ export class ConsensusError {
         }
         return ConsensusError.__wrap(ret[0]);
     }
+    /**
+     * The reference-validation error this is, or `undefined` when it is
+     * not one of codes 40120-40125.
+     * @returns {DocumentReferenceErrorCode | undefined}
+     */
+    get documentReferenceErrorCode() {
+        const ret = wasm.consensuserror_document_reference_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
     /**
      * @returns {string}
      */
@@ -3249,6 +3271,47 @@ export class DataContract {
         DataContractFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * 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 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
@@ -6251,6 +6314,60 @@ export class DocumentPurchaseTransition {
 }
 if (Symbol.dispose) DocumentPurchaseTransition.prototype[Symbol.dispose] = DocumentPurchaseTransition.prototype.free;
 
+/**
+ * Consensus error codes emitted by `refersTo` reference validation, which
+ * runs from protocol version 14 onward.
+ *
+ * Branch on an error's `code` against these instead of matching its
+ * message. Both directions work — `DocumentReferenceErrorCode[40123]` is
+ * `"ReferencedIdentityKeyNotFound"`.
+ *
+ * These reach JS on the state-transition broadcast path, where the
+ * consensus code is carried through to `WasmSdkError.code`:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.create({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentReferenceErrorCode.ReferencedIdentityKeyDisabled) {
+ *     // the referenced key exists but was disabled
+ *   }
+ * }
+ * ```
+ * @enum {40120 | 40121 | 40122 | 40123 | 40124 | 40125}
+ */
+export const DocumentReferenceErrorCode = Object.freeze({
+    /**
+     * The referenced identity, contract, token or permanent document 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.
+     */
+    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.
+     */
+    ReferencedDocumentTypeDeletable: 40122, "40122": "ReferencedDocumentTypeDeletable",
+    /**
+     * The referenced identity public key does not exist.
+     */
+    ReferencedIdentityKeyNotFound: 40123, "40123": "ReferencedIdentityKeyNotFound",
+    /**
+     * The referenced identity public key exists but is disabled.
+     */
+    ReferencedIdentityKeyDisabled: 40124, "40124": "ReferencedIdentityKeyDisabled",
+    /**
+     * The declaration's `keyIdProperty` is missing from the document type,
+     * or names a property that is not an integer.
+     */
+    ReferencedKeyIdPropertyInvalid: 40125, "40125": "ReferencedKeyIdPropertyInvalid",
+});
+
 export class DocumentReplaceTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -11626,177 +11743,161 @@ export class IdentityTopUpFromAddressesTransition {
 }
 if (Symbol.dispose) IdentityTopUpFromAddressesTransition.prototype[Symbol.dispose] = IdentityTopUpFromAddressesTransition.prototype.free;
 
-export class IdentityTopUpTransition {
+export class IdentityTopUpFromShieldedPoolTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(IdentityTopUpTransition.prototype);
+        const obj = Object.create(IdentityTopUpFromShieldedPoolTransition.prototype);
         obj.__wbg_ptr = ptr;
-        IdentityTopUpTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        IdentityTopUpFromShieldedPoolTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        IdentityTopUpTransitionFinalization.unregister(this);
+        IdentityTopUpFromShieldedPoolTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_identitytopuptransition_free(ptr, 0);
+        wasm.__wbg_identitytopupfromshieldedpooltransition_free(ptr, 0);
     }
     /**
-     * @returns {AssetLockProof}
+     * Returns the serialized Orchard actions.
+     * @returns {SerializedOrchardAction[]}
      */
-    get assetLockProof() {
-        const ret = wasm.identitytopuptransition_asset_lock_proof(this.__wbg_ptr);
-        return AssetLockProof.__wrap(ret);
+    get actions() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_actions(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * @param {IdentityTopUpTransitionOptions} options
+     * @returns {Uint8Array}
      */
-    constructor(options) {
-        const ret = wasm.identitytopuptransition_constructor(options);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        IdentityTopUpTransitionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    get anchor() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_anchor(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get bindingSignature() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_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 {string} base64
-     * @returns {IdentityTopUpTransition}
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
     static fromBase64(base64) {
         const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitytopuptransition_fromBase64(ptr0, len0);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromBase64(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityTopUpTransition.__wrap(ret[0]);
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
      * @param {Uint8Array} bytes
-     * @returns {IdentityTopUpTransition}
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
     static fromBytes(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitytopuptransition_fromBytes(ptr0, len0);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromBytes(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityTopUpTransition.__wrap(ret[0]);
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
      * @param {string} hex
-     * @returns {IdentityTopUpTransition}
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
     static fromHex(hex) {
         const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitytopuptransition_fromHex(ptr0, len0);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromHex(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityTopUpTransition.__wrap(ret[0]);
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
-     * @param {IdentityTopUpTransitionJSON} js
-     * @returns {IdentityTopUpTransition}
+     * @param {IdentityTopUpFromShieldedPoolTransitionJSON} js
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
     static fromJSON(js) {
-        const ret = wasm.identitytopuptransition_fromJSON(js);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityTopUpTransition.__wrap(ret[0]);
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
-     * @param {IdentityTopUpTransitionObject} obj
-     * @returns {IdentityTopUpTransition}
+     * @param {IdentityTopUpFromShieldedPoolTransitionObject} obj
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
     static fromObject(obj) {
-        const ret = wasm.identitytopuptransition_fromObject(obj);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityTopUpTransition.__wrap(ret[0]);
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
      * @param {StateTransition} st
-     * @returns {IdentityTopUpTransition}
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
     static fromStateTransition(st) {
         _assertClass(st, StateTransition);
-        const ret = wasm.identitytopuptransition_fromStateTransition(st.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromStateTransition(st.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityTopUpTransition.__wrap(ret[0]);
-    }
-    /**
-     * @returns {Identifier}
-     */
-    get identityIdentifier() {
-        const ret = wasm.identitytopuptransition_identity_identifier(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
      * @returns {Identifier[]}
      */
-    get modifiedDataIds() {
-        const ret = wasm.identitytopuptransition_modified_data_ids(this.__wbg_ptr);
+    getModifiedDataIds() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_getModifiedDataIds(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
     /**
-     * @returns {AssetLockProof | undefined}
-     */
-    get optionalAssetLockProof() {
-        const ret = wasm.identitytopuptransition_optional_asset_lock_proof(this.__wbg_ptr);
-        return ret === 0 ? undefined : AssetLockProof.__wrap(ret);
-    }
-    /**
-     * @param {AssetLockProof} assetLockProof
+     * The identity whose balance receives the top-up. Read-only: the identity id
+     * and the gross amount are committed into the Orchard binding signature, so a
+     * wrapper that changed them would produce a transition consensus must reject.
+     * @returns {Identifier}
      */
-    set assetLockProof(assetLockProof) {
-        _assertClass(assetLockProof, AssetLockProof);
-        const ret = wasm.identitytopuptransition_set_asset_lock_proof(this.__wbg_ptr, assetLockProof.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    get identityId() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
-     * @param {IdentifierLike} identityIdentifier
+     * @param {IdentityTopUpFromShieldedPoolTransitionOptions} options
      */
-    set identityIdentifier(identityIdentifier) {
-        const ret = wasm.identitytopuptransition_set_identity_identifier(this.__wbg_ptr, identityIdentifier);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    constructor(options) {
+        const ret = wasm.identitytopupfromshieldedpooltransition_new(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
-    }
-    /**
-     * @param {Uint8Array} signature
-     */
-    set signature(signature) {
-        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.identitytopuptransition_set_signature(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @param {number} userFeeIncrease
-     */
-    set userFeeIncrease(userFeeIncrease) {
-        wasm.identitytopuptransition_set_user_fee_increase(this.__wbg_ptr, userFeeIncrease);
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityTopUpFromShieldedPoolTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * @returns {Uint8Array}
      */
-    get signature() {
-        const ret = wasm.identitytopuptransition_signature(this.__wbg_ptr);
+    get proof() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_proof(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -11808,7 +11909,7 @@ export class IdentityTopUpTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.identitytopuptransition_struct_name();
+            const ret = wasm.identitytopupfromshieldedpooltransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -11823,7 +11924,7 @@ export class IdentityTopUpTransition {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.identitytopuptransition_toBase64(this.__wbg_ptr);
+            const ret = wasm.identitytopupfromshieldedpooltransition_toBase64(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -11841,7 +11942,7 @@ export class IdentityTopUpTransition {
      * @returns {Uint8Array}
      */
     toBytes() {
-        const ret = wasm.identitytopuptransition_toBytes(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toBytes(this.__wbg_ptr);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -11856,7 +11957,7 @@ export class IdentityTopUpTransition {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.identitytopuptransition_toHex(this.__wbg_ptr);
+            const ret = wasm.identitytopupfromshieldedpooltransition_toHex(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -11871,20 +11972,20 @@ export class IdentityTopUpTransition {
         }
     }
     /**
-     * @returns {IdentityTopUpTransitionJSON}
+     * @returns {IdentityTopUpFromShieldedPoolTransitionJSON}
      */
     toJSON() {
-        const ret = wasm.identitytopuptransition_toJSON(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {IdentityTopUpTransitionObject}
+     * @returns {IdentityTopUpFromShieldedPoolTransitionObject}
      */
     toObject() {
-        const ret = wasm.identitytopuptransition_toObject(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toObject(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -11894,9 +11995,17 @@ export class IdentityTopUpTransition {
      * @returns {StateTransition}
      */
     toStateTransition() {
-        const ret = wasm.identitytopuptransition_toStateTransition(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toStateTransition(this.__wbg_ptr);
         return StateTransition.__wrap(ret);
     }
+    /**
+     * Gross credits leaving the pool; the identity receives this minus the flat fee.
+     * @returns {bigint}
+     */
+    get topUpAmount() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_top_up_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * @returns {string}
      */
@@ -11904,7 +12013,7 @@ export class IdentityTopUpTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.identitytopuptransition_type_name(this.__wbg_ptr);
+            const ret = wasm.identitytopupfromshieldedpooltransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -11912,140 +12021,429 @@ export class IdentityTopUpTransition {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @returns {number}
-     */
-    get userFeeIncrease() {
-        const ret = wasm.identitytopuptransition_user_fee_increase(this.__wbg_ptr);
-        return ret;
-    }
 }
-if (Symbol.dispose) IdentityTopUpTransition.prototype[Symbol.dispose] = IdentityTopUpTransition.prototype.free;
+if (Symbol.dispose) IdentityTopUpFromShieldedPoolTransition.prototype[Symbol.dispose] = IdentityTopUpFromShieldedPoolTransition.prototype.free;
 
-export class IdentityUpdateTransition {
+export class IdentityTopUpTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(IdentityUpdateTransition.prototype);
+        const obj = Object.create(IdentityTopUpTransition.prototype);
         obj.__wbg_ptr = ptr;
-        IdentityUpdateTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        IdentityTopUpTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        IdentityUpdateTransitionFinalization.unregister(this);
+        IdentityTopUpTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_identityupdatetransition_free(ptr, 0);
+        wasm.__wbg_identitytopuptransition_free(ptr, 0);
     }
     /**
-     * @param {IdentityUpdateTransitionOptions} options
+     * @returns {AssetLockProof}
+     */
+    get assetLockProof() {
+        const ret = wasm.identitytopuptransition_asset_lock_proof(this.__wbg_ptr);
+        return AssetLockProof.__wrap(ret);
+    }
+    /**
+     * @param {IdentityTopUpTransitionOptions} options
      */
     constructor(options) {
-        const ret = wasm.identityupdatetransition_constructor(options);
+        const ret = wasm.identitytopuptransition_constructor(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        IdentityUpdateTransitionFinalization.register(this, this.__wbg_ptr, this);
+        IdentityTopUpTransitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * @param {string} base64
-     * @returns {IdentityUpdateTransition}
+     * @returns {IdentityTopUpTransition}
      */
     static fromBase64(base64) {
         const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identityupdatetransition_fromBase64(ptr0, len0);
+        const ret = wasm.identitytopuptransition_fromBase64(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityUpdateTransition.__wrap(ret[0]);
+        return IdentityTopUpTransition.__wrap(ret[0]);
     }
     /**
      * @param {Uint8Array} bytes
-     * @returns {IdentityUpdateTransition}
+     * @returns {IdentityTopUpTransition}
      */
     static fromBytes(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identityupdatetransition_fromBytes(ptr0, len0);
+        const ret = wasm.identitytopuptransition_fromBytes(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityUpdateTransition.__wrap(ret[0]);
+        return IdentityTopUpTransition.__wrap(ret[0]);
     }
     /**
      * @param {string} hex
-     * @returns {IdentityUpdateTransition}
+     * @returns {IdentityTopUpTransition}
      */
     static fromHex(hex) {
         const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identityupdatetransition_fromHex(ptr0, len0);
+        const ret = wasm.identitytopuptransition_fromHex(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityUpdateTransition.__wrap(ret[0]);
+        return IdentityTopUpTransition.__wrap(ret[0]);
     }
     /**
-     * @param {IdentityUpdateTransitionJSON} js
-     * @returns {IdentityUpdateTransition}
+     * @param {IdentityTopUpTransitionJSON} js
+     * @returns {IdentityTopUpTransition}
      */
     static fromJSON(js) {
-        const ret = wasm.identityupdatetransition_fromJSON(js);
+        const ret = wasm.identitytopuptransition_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityUpdateTransition.__wrap(ret[0]);
+        return IdentityTopUpTransition.__wrap(ret[0]);
     }
     /**
-     * @param {IdentityUpdateTransitionObject} obj
-     * @returns {IdentityUpdateTransition}
+     * @param {IdentityTopUpTransitionObject} obj
+     * @returns {IdentityTopUpTransition}
      */
     static fromObject(obj) {
-        const ret = wasm.identityupdatetransition_fromObject(obj);
+        const ret = wasm.identitytopuptransition_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityUpdateTransition.__wrap(ret[0]);
+        return IdentityTopUpTransition.__wrap(ret[0]);
     }
     /**
      * @param {StateTransition} st
-     * @returns {IdentityUpdateTransition}
+     * @returns {IdentityTopUpTransition}
      */
     static fromStateTransition(st) {
         _assertClass(st, StateTransition);
-        const ret = wasm.identityupdatetransition_fromStateTransition(st.__wbg_ptr);
+        const ret = wasm.identitytopuptransition_fromStateTransition(st.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityUpdateTransition.__wrap(ret[0]);
+        return IdentityTopUpTransition.__wrap(ret[0]);
     }
     /**
      * @returns {Identifier}
      */
     get identityIdentifier() {
-        const ret = wasm.identityupdatetransition_identity_identifier(this.__wbg_ptr);
+        const ret = wasm.identitytopuptransition_identity_identifier(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
     /**
      * @returns {Identifier[]}
      */
     get modifiedDataIds() {
-        const ret = wasm.identityupdatetransition_modified_data_ids(this.__wbg_ptr);
+        const ret = wasm.identitytopuptransition_modified_data_ids(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
     /**
-     * @returns {bigint}
+     * @returns {AssetLockProof | undefined}
      */
-    get nonce() {
-        const ret = wasm.identityupdatetransition_nonce(this.__wbg_ptr);
+    get optionalAssetLockProof() {
+        const ret = wasm.identitytopuptransition_optional_asset_lock_proof(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetLockProof.__wrap(ret);
+    }
+    /**
+     * @param {AssetLockProof} assetLockProof
+     */
+    set assetLockProof(assetLockProof) {
+        _assertClass(assetLockProof, AssetLockProof);
+        const ret = wasm.identitytopuptransition_set_asset_lock_proof(this.__wbg_ptr, assetLockProof.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {IdentifierLike} identityIdentifier
+     */
+    set identityIdentifier(identityIdentifier) {
+        const ret = wasm.identitytopuptransition_set_identity_identifier(this.__wbg_ptr, identityIdentifier);
+        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.identitytopuptransition_set_signature(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} userFeeIncrease
+     */
+    set userFeeIncrease(userFeeIncrease) {
+        wasm.identitytopuptransition_set_user_fee_increase(this.__wbg_ptr, userFeeIncrease);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.identitytopuptransition_signature(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.identitytopuptransition_struct_name();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    toBase64() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitytopuptransition_toBase64(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.identitytopuptransition_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    toHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitytopuptransition_toHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {IdentityTopUpTransitionJSON}
+     */
+    toJSON() {
+        const ret = wasm.identitytopuptransition_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {IdentityTopUpTransitionObject}
+     */
+    toObject() {
+        const ret = wasm.identitytopuptransition_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.identitytopuptransition_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitytopuptransition_type_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get userFeeIncrease() {
+        const ret = wasm.identitytopuptransition_user_fee_increase(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) IdentityTopUpTransition.prototype[Symbol.dispose] = IdentityTopUpTransition.prototype.free;
+
+export class IdentityUpdateTransition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityUpdateTransition.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityUpdateTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityUpdateTransitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identityupdatetransition_free(ptr, 0);
+    }
+    /**
+     * @param {IdentityUpdateTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.identityupdatetransition_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityUpdateTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} base64
+     * @returns {IdentityUpdateTransition}
+     */
+    static fromBase64(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identityupdatetransition_fromBase64(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityUpdateTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {IdentityUpdateTransition}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identityupdatetransition_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityUpdateTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} hex
+     * @returns {IdentityUpdateTransition}
+     */
+    static fromHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identityupdatetransition_fromHex(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityUpdateTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityUpdateTransitionJSON} js
+     * @returns {IdentityUpdateTransition}
+     */
+    static fromJSON(js) {
+        const ret = wasm.identityupdatetransition_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityUpdateTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityUpdateTransitionObject} obj
+     * @returns {IdentityUpdateTransition}
+     */
+    static fromObject(obj) {
+        const ret = wasm.identityupdatetransition_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityUpdateTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {StateTransition} st
+     * @returns {IdentityUpdateTransition}
+     */
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.identityupdatetransition_fromStateTransition(st.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityUpdateTransition.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get identityIdentifier() {
+        const ret = wasm.identityupdatetransition_identity_identifier(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {Identifier[]}
+     */
+    get modifiedDataIds() {
+        const ret = wasm.identityupdatetransition_modified_data_ids(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get nonce() {
+        const ret = wasm.identityupdatetransition_nonce(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -14957,7 +15355,7 @@ export class SharedEncryptedNote {
     constructor(senderKeyIndex, recipientKeyIndex, value) {
         const ptr0 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.privateencryptednote_constructor(senderKeyIndex, recipientKeyIndex, ptr0, len0);
+        const ret = wasm.sharedencryptednote_constructor(senderKeyIndex, recipientKeyIndex, ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
         SharedEncryptedNoteFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -15003,7 +15401,181 @@ export class SharedEncryptedNote {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.sharedencryptednote_struct_name();
+            const ret = wasm.sharedencryptednote_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.sharedencryptednote_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 {Uint8Array}
+     */
+    get value() {
+        const ret = wasm.sharedencryptednote_value(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) SharedEncryptedNote.prototype[Symbol.dispose] = SharedEncryptedNote.prototype.free;
+
+export class ShieldFromAssetLockTransition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ShieldFromAssetLockTransition.prototype);
+        obj.__wbg_ptr = ptr;
+        ShieldFromAssetLockTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ShieldFromAssetLockTransitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_shieldfromassetlocktransition_free(ptr, 0);
+    }
+    /**
+     * Returns the serialized Orchard actions.
+     * @returns {SerializedOrchardAction[]}
+     */
+    get actions() {
+        const ret = wasm.shieldfromassetlocktransition_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.shieldfromassetlocktransition_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 asset lock proof.
+     * @returns {AssetLockProof}
+     */
+    get assetLockProof() {
+        const ret = wasm.shieldfromassetlocktransition_asset_lock_proof(this.__wbg_ptr);
+        return AssetLockProof.__wrap(ret);
+    }
+    /**
+     * Returns the RedPallas binding signature (64 bytes).
+     * @returns {Uint8Array}
+     */
+    get bindingSignature() {
+        const ret = wasm.shieldfromassetlocktransition_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 {ShieldFromAssetLockTransition}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.shieldfromassetlocktransition_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShieldFromAssetLockTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {ShieldFromAssetLockTransitionJSON} js
+     * @returns {ShieldFromAssetLockTransition}
+     */
+    static fromJSON(js) {
+        const ret = wasm.shieldfromassetlocktransition_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShieldFromAssetLockTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {ShieldFromAssetLockTransitionObject} obj
+     * @returns {ShieldFromAssetLockTransition}
+     */
+    static fromObject(obj) {
+        const ret = wasm.shieldfromassetlocktransition_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShieldFromAssetLockTransition.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Identifier[]}
+     */
+    getModifiedDataIds() {
+        const ret = wasm.shieldfromassetlocktransition_getModifiedDataIds(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {ShieldFromAssetLockTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.shieldfromassetlocktransition_new(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ShieldFromAssetLockTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the Halo2 proof bytes.
+     * @returns {Uint8Array}
+     */
+    get proof() {
+        const ret = wasm.shieldfromassetlocktransition_proof(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns the ECDSA signature.
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.shieldfromassetlocktransition_signature(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.shieldfromassetlocktransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -15011,6 +15583,54 @@ export class SharedEncryptedNote {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Returns the optional surplus-output platform address, or
+     * `undefined` when the surplus folds into the fee pools.
+     * @returns {PlatformAddress | undefined}
+     */
+    get surplusOutput() {
+        const ret = wasm.shieldfromassetlocktransition_surplus_output(this.__wbg_ptr);
+        return ret === 0 ? undefined : PlatformAddress.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.shieldfromassetlocktransition_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 {ShieldFromAssetLockTransitionJSON}
+     */
+    toJSON() {
+        const ret = wasm.shieldfromassetlocktransition_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {ShieldFromAssetLockTransitionObject}
+     */
+    toObject() {
+        const ret = wasm.shieldfromassetlocktransition_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.shieldfromassetlocktransition_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
+    }
     /**
      * @returns {string}
      */
@@ -15018,7 +15638,7 @@ export class SharedEncryptedNote {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.sharedencryptednote_type_name(this.__wbg_ptr);
+            const ret = wasm.shieldfromassetlocktransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -15027,149 +15647,251 @@ export class SharedEncryptedNote {
         }
     }
     /**
-     * @returns {Uint8Array}
+     * Returns the net value balance.
+     * @returns {bigint}
      */
-    get value() {
-        const ret = wasm.sharedencryptednote_value(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+    get valueBalance() {
+        const ret = wasm.shieldfromassetlocktransition_value_balance(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
 }
-if (Symbol.dispose) SharedEncryptedNote.prototype[Symbol.dispose] = SharedEncryptedNote.prototype.free;
+if (Symbol.dispose) ShieldFromAssetLockTransition.prototype[Symbol.dispose] = ShieldFromAssetLockTransition.prototype.free;
 
-export class ShieldFromAssetLockTransition {
+export class ShieldFromIdentityTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ShieldFromAssetLockTransition.prototype);
+        const obj = Object.create(ShieldFromIdentityTransition.prototype);
         obj.__wbg_ptr = ptr;
-        ShieldFromAssetLockTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        ShieldFromIdentityTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ShieldFromAssetLockTransitionFinalization.unregister(this);
+        ShieldFromIdentityTransitionFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_shieldfromassetlocktransition_free(ptr, 0);
+        wasm.__wbg_shieldfromidentitytransition_free(ptr, 0);
     }
     /**
      * Returns the serialized Orchard actions.
      * @returns {SerializedOrchardAction[]}
      */
     get actions() {
-        const ret = wasm.shieldfromassetlocktransition_actions(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_actions(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Credits leaving the identity balance and entering the pool.
+     * @returns {bigint}
+     */
+    get amount() {
+        const ret = wasm.shieldfromidentitytransition_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * Returns the anchor (32-byte Merkle root).
      * @returns {Uint8Array}
      */
     get anchor() {
-        const ret = wasm.shieldfromassetlocktransition_anchor(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_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 asset lock proof.
-     * @returns {AssetLockProof}
-     */
-    get assetLockProof() {
-        const ret = wasm.shieldfromassetlocktransition_asset_lock_proof(this.__wbg_ptr);
-        return AssetLockProof.__wrap(ret);
-    }
     /**
      * Returns the RedPallas binding signature (64 bytes).
      * @returns {Uint8Array}
      */
     get bindingSignature() {
-        const ret = wasm.shieldfromassetlocktransition_binding_signature(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_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 {string} base64
+     * @returns {ShieldFromIdentityTransition}
+     */
+    static fromBase64(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.shieldfromidentitytransition_fromBase64(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShieldFromIdentityTransition.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} bytes
-     * @returns {ShieldFromAssetLockTransition}
+     * @returns {ShieldFromIdentityTransition}
      */
     static fromBytes(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.shieldfromassetlocktransition_fromBytes(ptr0, len0);
+        const ret = wasm.shieldfromidentitytransition_fromBytes(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ShieldFromAssetLockTransition.__wrap(ret[0]);
+        return ShieldFromIdentityTransition.__wrap(ret[0]);
     }
     /**
-     * @param {ShieldFromAssetLockTransitionJSON} js
-     * @returns {ShieldFromAssetLockTransition}
+     * @param {string} hex
+     * @returns {ShieldFromIdentityTransition}
+     */
+    static fromHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.shieldfromidentitytransition_fromHex(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShieldFromIdentityTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {ShieldFromIdentityTransitionJSON} js
+     * @returns {ShieldFromIdentityTransition}
      */
     static fromJSON(js) {
-        const ret = wasm.shieldfromassetlocktransition_fromJSON(js);
+        const ret = wasm.shieldfromidentitytransition_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ShieldFromAssetLockTransition.__wrap(ret[0]);
+        return ShieldFromIdentityTransition.__wrap(ret[0]);
     }
     /**
-     * @param {ShieldFromAssetLockTransitionObject} obj
-     * @returns {ShieldFromAssetLockTransition}
+     * @param {ShieldFromIdentityTransitionObject} obj
+     * @returns {ShieldFromIdentityTransition}
      */
     static fromObject(obj) {
-        const ret = wasm.shieldfromassetlocktransition_fromObject(obj);
+        const ret = wasm.shieldfromidentitytransition_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ShieldFromAssetLockTransition.__wrap(ret[0]);
+        return ShieldFromIdentityTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {StateTransition} st
+     * @returns {ShieldFromIdentityTransition}
+     */
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.shieldfromidentitytransition_fromStateTransition(st.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShieldFromIdentityTransition.__wrap(ret[0]);
     }
     /**
      * @returns {Identifier[]}
      */
     getModifiedDataIds() {
-        const ret = wasm.shieldfromassetlocktransition_getModifiedDataIds(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_getModifiedDataIds(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
     /**
-     * @param {ShieldFromAssetLockTransitionOptions} options
+     * The identity whose balance funds the shield.
+     * @returns {Identifier}
+     */
+    get identityId() {
+        const ret = wasm.shieldfromidentitytransition_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @param {ShieldFromIdentityTransitionOptions} options
      */
     constructor(options) {
-        const ret = wasm.shieldfromassetlocktransition_new(options);
+        const ret = wasm.shieldfromidentitytransition_new(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        ShieldFromAssetLockTransitionFinalization.register(this, this.__wbg_ptr, this);
+        ShieldFromIdentityTransitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @returns {bigint}
+     */
+    get nonce() {
+        const ret = wasm.shieldfromidentitytransition_nonce(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * Returns the Halo2 proof bytes.
      * @returns {Uint8Array}
      */
     get proof() {
-        const ret = wasm.shieldfromassetlocktransition_proof(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_proof(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
     /**
-     * Returns the ECDSA signature.
+     * @param {IdentifierLike} identity_id
+     */
+    set identityId(identity_id) {
+        const ret = wasm.shieldfromidentitytransition_set_identity_id(this.__wbg_ptr, identity_id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {bigint} nonce
+     */
+    set nonce(nonce) {
+        const ret = wasm.shieldfromidentitytransition_set_nonce(this.__wbg_ptr, nonce);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Uint8Array} signature
+     */
+    set signature(signature) {
+        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.shieldfromidentitytransition_set_signature(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} publicKeyId
+     */
+    set signaturePublicKeyId(publicKeyId) {
+        const ret = wasm.shieldfromidentitytransition_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.shieldfromidentitytransition_set_user_fee_increase(this.__wbg_ptr, amount);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
      * @returns {Uint8Array}
      */
     get signature() {
-        const ret = wasm.shieldfromassetlocktransition_signature(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_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.shieldfromidentitytransition_signature_public_key_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @returns {string}
      */
@@ -15177,7 +15899,7 @@ export class ShieldFromAssetLockTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.shieldfromassetlocktransition_struct_name();
+            const ret = wasm.shieldfromidentitytransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -15186,19 +15908,31 @@ export class ShieldFromAssetLockTransition {
         }
     }
     /**
-     * Returns the optional surplus-output platform address, or
-     * `undefined` when the surplus folds into the fee pools.
-     * @returns {PlatformAddress | undefined}
+     * @returns {string}
      */
-    get surplusOutput() {
-        const ret = wasm.shieldfromassetlocktransition_surplus_output(this.__wbg_ptr);
-        return ret === 0 ? undefined : PlatformAddress.__wrap(ret);
+    toBase64() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.shieldfromidentitytransition_toBase64(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
     /**
      * @returns {Uint8Array}
      */
     toBytes() {
-        const ret = wasm.shieldfromassetlocktransition_toBytes(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_toBytes(this.__wbg_ptr);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -15207,20 +15941,41 @@ export class ShieldFromAssetLockTransition {
         return v1;
     }
     /**
-     * @returns {ShieldFromAssetLockTransitionJSON}
+     * @returns {string}
+     */
+    toHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.shieldfromidentitytransition_toHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {ShieldFromIdentityTransitionJSON}
      */
     toJSON() {
-        const ret = wasm.shieldfromassetlocktransition_toJSON(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {ShieldFromAssetLockTransitionObject}
+     * @returns {ShieldFromIdentityTransitionObject}
      */
     toObject() {
-        const ret = wasm.shieldfromassetlocktransition_toObject(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_toObject(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -15230,7 +15985,7 @@ export class ShieldFromAssetLockTransition {
      * @returns {StateTransition}
      */
     toStateTransition() {
-        const ret = wasm.shieldfromassetlocktransition_toStateTransition(this.__wbg_ptr);
+        const ret = wasm.shieldfromidentitytransition_toStateTransition(this.__wbg_ptr);
         return StateTransition.__wrap(ret);
     }
     /**
@@ -15240,7 +15995,7 @@ export class ShieldFromAssetLockTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.shieldfromassetlocktransition_type_name(this.__wbg_ptr);
+            const ret = wasm.shieldfromidentitytransition_type_name(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -15249,15 +16004,14 @@ export class ShieldFromAssetLockTransition {
         }
     }
     /**
-     * Returns the net value balance.
-     * @returns {bigint}
+     * @returns {number}
      */
-    get valueBalance() {
-        const ret = wasm.shieldfromassetlocktransition_value_balance(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get userFeeIncrease() {
+        const ret = wasm.shieldfromidentitytransition_user_fee_increase(this.__wbg_ptr);
+        return ret;
     }
 }
-if (Symbol.dispose) ShieldFromAssetLockTransition.prototype[Symbol.dispose] = ShieldFromAssetLockTransition.prototype.free;
+if (Symbol.dispose) ShieldFromIdentityTransition.prototype[Symbol.dispose] = ShieldFromIdentityTransition.prototype.free;
 
 export class ShieldTransition {
     static __wrap(ptr) {
@@ -18169,7 +18923,7 @@ export class TokenDistributionRecipient {
      * @returns {TokenDistributionRecipient}
      */
     static ContractOwner() {
-        const ret = wasm.authorizedactiontakers_NoOne();
+        const ret = wasm.tokendistributionrecipient_ContractOwner();
         return TokenDistributionRecipient.__wrap(ret);
     }
     /**
@@ -21380,7 +22134,7 @@ export class VerifiedIdentityFullWithAddressInfos {
     set identity(arg0) {
         _assertClass(arg0, Identity);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedidentityfullwithaddressinfos_identity(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedidentity_identity(this.__wbg_ptr, ptr0);
     }
     /**
      * @returns {Map<any, any>}
@@ -21497,7 +22251,7 @@ export class VerifiedIdentityWithAddressInfos {
     set partialIdentity(arg0) {
         _assertClass(arg0, PartialIdentity);
         var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_verifiedidentitywithaddressinfos_partialIdentity(this.__wbg_ptr, ptr0);
+        wasm.__wbg_set_verifiedbalancetransfer_sender(this.__wbg_ptr, ptr0);
     }
     /**
      * @returns {Map<any, any>}
@@ -21834,7 +22588,7 @@ export class VerifiedNextDistribution {
      * @returns {Vote}
      */
     get vote() {
-        const ret = wasm.__wbg_get_verifiednextdistribution_vote(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_verifiedmasternodevote_vote(this.__wbg_ptr);
         return Vote.__wrap(ret);
     }
     /**
@@ -24459,7 +25213,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h9f47b8974001e8c8(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_208f8721039e7b97___convert__closures_____invoke___wasm_bindgen_208f8721039e7b97___JsValue__wasm_bindgen_208f8721039e7b97___JsValue_____(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -24856,8 +25610,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h9f47b8974001e8c8(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h9f47b8974001e8c8(arg0, arg1, arg2, arg3);
+function wasm_bindgen_208f8721039e7b97___convert__closures_____invoke___wasm_bindgen_208f8721039e7b97___JsValue__wasm_bindgen_208f8721039e7b97___JsValue_____(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_208f8721039e7b97___convert__closures_____invoke___wasm_bindgen_208f8721039e7b97___JsValue__wasm_bindgen_208f8721039e7b97___JsValue_____(arg0, arg1, arg2, arg3);
 }
 
 const ActionTakerFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -25043,6 +25797,9 @@ const IdentityTokenInfoFinalization = (typeof FinalizationRegistry === 'undefine
 const IdentityTopUpFromAddressesTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitytopupfromaddressestransition_free(ptr >>> 0, 1));
+const IdentityTopUpFromShieldedPoolTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitytopupfromshieldedpooltransition_free(ptr >>> 0, 1));
 const IdentityTopUpTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitytopuptransition_free(ptr >>> 0, 1));
@@ -25109,6 +25866,9 @@ const SharedEncryptedNoteFinalization = (typeof FinalizationRegistry === 'undefi
 const ShieldFromAssetLockTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_shieldfromassetlocktransition_free(ptr >>> 0, 1));
+const ShieldFromIdentityTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_shieldfromidentitytransition_free(ptr >>> 0, 1));
 const ShieldTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_shieldtransition_free(ptr >>> 0, 1));