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

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,24 @@ export class ConsensusError {
         }
         return ConsensusError.__wrap(ret[0]);
     }
+    /**
+     * The immutable-property error this is, or `undefined` when it is not
+     * code 40128.
+     * @returns {DocumentImmutabilityErrorCode | undefined}
+     */
+    get documentImmutabilityErrorCode() {
+        const ret = wasm.consensuserror_document_immutability_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
+    /**
+     * The reference-validation error this is, or `undefined` when it is
+     * not one of codes 40120-40125.
+     * @returns {DocumentReferenceErrorCode | undefined}
+     */
+    get documentReferenceErrorCode() {
+        const ret = wasm.consensuserror_document_reference_error_code(this.__wbg_ptr);
+        return ret === 0 ? undefined : ret;
+    }
     /**
      * @returns {string}
      */
@@ -2858,6 +2889,18 @@ export class ContractBounds {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_contractbounds_free(ptr, 0);
     }
+    /**
+     * Bounds to every member of a contract group. Only authentication keys may carry them.
+     * @param {IdentifierLike} contractGroupId
+     * @returns {ContractBounds}
+     */
+    static ContractGroup(contractGroupId) {
+        const ret = wasm.contractbounds_ContractGroup(contractGroupId);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractBounds.__wrap(ret[0]);
+    }
     /**
      * @param {IdentifierLike} contractId
      * @returns {ContractBounds}
@@ -2920,6 +2963,14 @@ export class ContractBounds {
         const ret = wasm.contractbounds_contract_bounds_type_number(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * The contract group id, for `contractGroup` bounds only.
+     * @returns {Identifier | undefined}
+     */
+    get contractGroupId() {
+        const ret = wasm.contractbounds_contract_group_id(this.__wbg_ptr);
+        return ret === 0 ? undefined : Identifier.__wrap(ret);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -2955,6 +3006,7 @@ export class ContractBounds {
         return ContractBounds.__wrap(ret[0]);
     }
     /**
+     * The contract id, or the contract group id for `contractGroup` bounds.
      * @returns {Identifier}
      */
     get identifier() {
@@ -3249,6 +3301,88 @@ export class DataContract {
         DataContractFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * The `immutable` / `immutableAllowSetting` declarations of one
+     * document type: `{ immutable: string[], immutableAllowSetting:
+     * string[] }`, both sorted by property name.
+     *
+     * Both arrays are empty when the document type declares nothing (the
+     * normal case, and the only case for a type whose documents are not
+     * mutable). Throws when the contract has no document type by that
+     * name, so "no such type" and "nothing frozen" stay distinguishable.
+     *
+     * The keywords are only parsed from protocol version 14 onward. A
+     * contract deserialized against an earlier platform version reports
+     * empty lists, which is exactly what consensus enforced at that
+     * version, while `toJSON()` still shows the raw keywords either way.
+     * @param {string} documentTypeName
+     * @returns {DocumentTypeImmutableProperties}
+     */
+    documentTypeImmutableProperties(documentTypeName) {
+        const ptr0 = passStringToWasm0(documentTypeName, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.datacontract_documentTypeImmutableProperties(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * All `refersTo` declarations of one document type, in schema property
+     * order.
+     *
+     * 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
@@ -3595,6 +3729,30 @@ export class DataContractCreateTransition {
         DataContractCreateTransitionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * The contract group this transition registers, as a `ContractGroupRegistrationObject`,
+     * or `undefined` when it registers none (a version 0 transition never does).
+     * @returns {any}
+     */
+    get contractGroup() {
+        const ret = wasm.datacontractcreatetransition_contract_group(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The contract group memberships the created contract declares, as
+     * `ContractGroupMembershipObject[]`; empty on a version 0 transition.
+     * @returns {any}
+     */
+    get contractGroupMemberships() {
+        const ret = wasm.datacontractcreatetransition_contract_group_memberships(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @returns {number}
      */
@@ -3694,6 +3852,28 @@ export class DataContractCreateTransition {
         const ret = wasm.datacontractcreatetransition_identity_nonce(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Registers a contract group with this transition, or clears the registration with
+     * `undefined`. Needs a version 1 transition (protocol version 14).
+     * @param {any} registration
+     */
+    setContractGroup(registration) {
+        const ret = wasm.datacontractcreatetransition_setContractGroup(this.__wbg_ptr, registration);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Declares which contract groups the created contract, its document types or its tokens
+     * join. Needs a version 1 transition (protocol version 14).
+     * @param {any} memberships
+     */
+    setContractGroupMemberships(memberships) {
+        const ret = wasm.datacontractcreatetransition_setContractGroupMemberships(this.__wbg_ptr, memberships);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {DataContract} dataContract
      * @param {PlatformVersionLike} platformVersion
@@ -6123,6 +6303,32 @@ export class DocumentDeleteTransition {
 }
 if (Symbol.dispose) DocumentDeleteTransition.prototype[Symbol.dispose] = DocumentDeleteTransition.prototype.free;
 
+/**
+ * Consensus error codes emitted by the immutable-property check on document
+ * replaces (`immutable` / `immutableAllowSetting`, protocol version 14+).
+ *
+ * Branch on an error's `code` against this instead of matching its message:
+ *
+ * ```js
+ * try {
+ *   await sdk.documents.replace({ document, identityKey, signer });
+ * } catch (e) {
+ *   if (e.code === DocumentImmutabilityErrorCode.DocumentImmutablePropertyChanged) {
+ *     // the replace touched a property the document type freezes
+ *   }
+ * }
+ * ```
+ * @enum {40128}
+ */
+export const DocumentImmutabilityErrorCode = Object.freeze({
+    /**
+     * The replace changed, added or removed a property the document type
+     * lists under `immutable`, and the change was not the one first-time
+     * set `immutableAllowSetting` permits.
+     */
+    DocumentImmutablePropertyChanged: 40128, "40128": "DocumentImmutablePropertyChanged",
+});
+
 export class DocumentPurchaseTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -6251,6 +6457,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;
@@ -10468,199 +10728,554 @@ export class IdentityCreditWithdrawalTransition {
 }
 if (Symbol.dispose) IdentityCreditWithdrawalTransition.prototype[Symbol.dispose] = IdentityCreditWithdrawalTransition.prototype.free;
 
-export class IdentityPublicKey {
+export class IdentityKeyLimitsUpdate {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(IdentityPublicKey.prototype);
+        const obj = Object.create(IdentityKeyLimitsUpdate.prototype);
         obj.__wbg_ptr = ptr;
-        IdentityPublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        IdentityKeyLimitsUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        IdentityPublicKeyFinalization.unregister(this);
+        IdentityKeyLimitsUpdateFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_identitypublickey_free(ptr, 0);
-    }
-    /**
-     * @returns {string}
-     */
-    base64() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.identitypublickey_base64(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);
-        }
+        wasm.__wbg_identitykeylimitsupdate_free(ptr, 0);
     }
     /**
-     * @param {IdentityPublicKeyOptions} options
+     * @param {IdentityKeyLimitsUpdateTransitionOptions} options
      */
     constructor(options) {
-        const ret = wasm.identitypublickey_constructor(options);
+        const ret = wasm.identitykeylimitsupdate_constructor(options);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        IdentityPublicKeyFinalization.register(this, this.__wbg_ptr, this);
+        IdentityKeyLimitsUpdateFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
-    /**
-     * @returns {ContractBounds | undefined}
-     */
-    get contractBounds() {
-        const ret = wasm.identitypublickey_contract_bounds(this.__wbg_ptr);
-        return ret === 0 ? undefined : ContractBounds.__wrap(ret);
-    }
-    /**
-     * @returns {string}
-     */
-    get data() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.identitypublickey_data(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 {bigint | undefined}
      */
-    get disabledAt() {
-        const ret = wasm.identitypublickey_disabled_at(this.__wbg_ptr);
+    get expiresAt() {
+        const ret = wasm.identitykeylimitsupdate_expires_at(this.__wbg_ptr);
         return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
     /**
-     * @param {string} hex
-     * @returns {IdentityPublicKey}
+     * @param {string} base64
+     * @returns {IdentityKeyLimitsUpdate}
      */
-    static fromBase64(hex) {
-        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    static fromBase64(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitypublickey_fromBase64(ptr0, len0);
+        const ret = wasm.identitykeylimitsupdate_fromBase64(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityPublicKey.__wrap(ret[0]);
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
     }
     /**
      * @param {Uint8Array} bytes
-     * @returns {IdentityPublicKey}
+     * @returns {IdentityKeyLimitsUpdate}
      */
     static fromBytes(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitypublickey_fromBytes(ptr0, len0);
+        const ret = wasm.identitykeylimitsupdate_fromBytes(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityPublicKey.__wrap(ret[0]);
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
     }
     /**
      * @param {string} hex
-     * @returns {IdentityPublicKey}
+     * @returns {IdentityKeyLimitsUpdate}
      */
     static fromHex(hex) {
         const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitypublickey_fromHex(ptr0, len0);
+        const ret = wasm.identitykeylimitsupdate_fromHex(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityPublicKey.__wrap(ret[0]);
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
     }
     /**
-     * Deserialize from JSON-compatible JS object (canonical wire shape).
-     *
-     * Expects base64 strings for binary fields, base58 strings for
-     * identifiers — the canonical shape produced by `toJSON`.
-     * `platform_version` is accepted for SDK API consistency but not
-     * load-bearing today (canonical tag-driven dispatch handles V0).
-     * @param {IdentityPublicKeyJSON} value
-     * @param {PlatformVersionLike} _platform_version
-     * @returns {IdentityPublicKey}
+     * @param {IdentityKeyLimitsUpdateJSON} js
+     * @returns {IdentityKeyLimitsUpdate}
      */
-    static fromJSON(value, _platform_version) {
-        const ret = wasm.identitypublickey_fromJSON(value, _platform_version);
+    static fromJSON(js) {
+        const ret = wasm.identitykeylimitsupdate_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityPublicKey.__wrap(ret[0]);
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
     }
     /**
-     * Deserialize from JS object (non-human-readable).
-     *
-     * Uses platform_value conversion which properly handles the tagged enum.
-     * `platform_version` is accepted for SDK API consistency but not
-     * load-bearing today — canonical `ValueConvertible::from_object`
-     * dispatches on the value's `$formatVersion` tag, which produces
-     * identical output for the only currently-defined V0.
-     * @param {IdentityPublicKeyObject} value
-     * @param {PlatformVersionLike} _platform_version
-     * @returns {IdentityPublicKey}
+     * @param {IdentityKeyLimitsUpdateObject} obj
+     * @returns {IdentityKeyLimitsUpdate}
      */
-    static fromObject(value, _platform_version) {
-        const ret = wasm.identitypublickey_fromObject(value, _platform_version);
+    static fromObject(obj) {
+        const ret = wasm.identitykeylimitsupdate_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return IdentityPublicKey.__wrap(ret[0]);
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
     }
     /**
-     * @returns {string}
+     * @param {StateTransition} st
+     * @returns {IdentityKeyLimitsUpdate}
      */
-    getPublicKeyHash() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.identitypublickey_getPublicKeyHash(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);
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.identitykeylimitsupdate_fromStateTransition(st.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return IdentityKeyLimitsUpdate.__wrap(ret[0]);
     }
     /**
-     * @returns {string}
+     * @returns {Identifier}
      */
-    hex() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.identitypublickey_hex(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;
+    get identityId() {
+        const ret = wasm.identitykeylimitsupdate_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get keyId() {
+        const ret = wasm.identitykeylimitsupdate_key_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get nonce() {
+        const ret = wasm.identitykeylimitsupdate_nonce(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {bigint | null} [expires_at]
+     */
+    set expiresAt(expires_at) {
+        const ret = wasm.identitykeylimitsupdate_set_expires_at(this.__wbg_ptr, isLikeNone(expires_at) ? 0 : addToExternrefTable0(expires_at));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {IdentifierLike} identity_id
+     */
+    set identityId(identity_id) {
+        const ret = wasm.identitykeylimitsupdate_set_identity_id(this.__wbg_ptr, identity_id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} key_id
+     */
+    set keyId(key_id) {
+        const ret = wasm.identitykeylimitsupdate_set_key_id(this.__wbg_ptr, key_id);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {bigint} nonce
+     */
+    set nonce(nonce) {
+        const ret = wasm.identitykeylimitsupdate_set_nonce(this.__wbg_ptr, nonce);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Uint8Array} signature
+     */
+    set signature(signature) {
+        const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.identitykeylimitsupdate_set_signature(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} publicKeyId
+     */
+    set signaturePublicKeyId(publicKeyId) {
+        const ret = wasm.identitykeylimitsupdate_set_signature_public_key_id(this.__wbg_ptr, publicKeyId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {bigint | null} [total_budget]
+     */
+    set totalBudget(total_budget) {
+        const ret = wasm.identitykeylimitsupdate_set_total_budget(this.__wbg_ptr, isLikeNone(total_budget) ? 0 : addToExternrefTable0(total_budget));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} amount
+     */
+    set userFeeIncrease(amount) {
+        const ret = wasm.identitykeylimitsupdate_set_user_fee_increase(this.__wbg_ptr, amount);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get signature() {
+        const ret = wasm.identitykeylimitsupdate_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get signaturePublicKeyId() {
+        const ret = wasm.identitykeylimitsupdate_signature_public_key_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_struct_name();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    toBase64() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_toBase64(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.identitykeylimitsupdate_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    toHex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_toHex(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @returns {IdentityKeyLimitsUpdateJSON}
+     */
+    toJSON() {
+        const ret = wasm.identitykeylimitsupdate_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {IdentityKeyLimitsUpdateObject}
+     */
+    toObject() {
+        const ret = wasm.identitykeylimitsupdate_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.identitykeylimitsupdate_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    get totalBudget() {
+        const ret = wasm.identitykeylimitsupdate_total_budget(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitykeylimitsupdate_type_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get userFeeIncrease() {
+        const ret = wasm.identitykeylimitsupdate_user_fee_increase(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) IdentityKeyLimitsUpdate.prototype[Symbol.dispose] = IdentityKeyLimitsUpdate.prototype.free;
+
+export class IdentityPublicKey {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityPublicKey.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityPublicKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityPublicKeyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitypublickey_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    base64() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitypublickey_base64(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);
+        }
+    }
+    /**
+     * @param {IdentityPublicKeyOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.identitypublickey_constructor(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityPublicKeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {ContractBounds | undefined}
+     */
+    get contractBounds() {
+        const ret = wasm.identitypublickey_contract_bounds(this.__wbg_ptr);
+        return ret === 0 ? undefined : ContractBounds.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get data() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitypublickey_data(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 {bigint | undefined}
+     */
+    get disabledAt() {
+        const ret = wasm.identitypublickey_disabled_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * The block time in milliseconds from which the key can no longer sign, `undefined` when
+     * it does not expire
+     * @returns {bigint | undefined}
+     */
+    get expiresAt() {
+        const ret = wasm.identitypublickey_expires_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @param {string} hex
+     * @returns {IdentityPublicKey}
+     */
+    static fromBase64(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitypublickey_fromBase64(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityPublicKey.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {IdentityPublicKey}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitypublickey_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityPublicKey.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} hex
+     * @returns {IdentityPublicKey}
+     */
+    static fromHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitypublickey_fromHex(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityPublicKey.__wrap(ret[0]);
+    }
+    /**
+     * Deserialize from JSON-compatible JS object (canonical wire shape).
+     *
+     * Expects base64 strings for binary fields, base58 strings for
+     * identifiers — the canonical shape produced by `toJSON`.
+     * `platform_version` is accepted for SDK API consistency but not
+     * load-bearing today (canonical tag-driven dispatch handles V0).
+     * @param {IdentityPublicKeyJSON} value
+     * @param {PlatformVersionLike} _platform_version
+     * @returns {IdentityPublicKey}
+     */
+    static fromJSON(value, _platform_version) {
+        const ret = wasm.identitypublickey_fromJSON(value, _platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityPublicKey.__wrap(ret[0]);
+    }
+    /**
+     * Deserialize from JS object (non-human-readable).
+     *
+     * Uses platform_value conversion which properly handles the tagged enum.
+     * `platform_version` is accepted for SDK API consistency but not
+     * load-bearing today — canonical `ValueConvertible::from_object`
+     * dispatches on the value's `$formatVersion` tag, which produces
+     * identical output for the only currently-defined V0.
+     * @param {IdentityPublicKeyObject} value
+     * @param {PlatformVersionLike} _platform_version
+     * @returns {IdentityPublicKey}
+     */
+    static fromObject(value, _platform_version) {
+        const ret = wasm.identitypublickey_fromObject(value, _platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityPublicKey.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    getPublicKeyHash() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitypublickey_getPublicKeyHash(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 {string}
+     */
+    hex() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.identitypublickey_hex(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);
@@ -10773,6 +11388,16 @@ export class IdentityPublicKey {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Setting an expiry on a version 0 key makes it a version 1 key
+     * @param {bigint | null} [expiresAt]
+     */
+    set expiresAt(expiresAt) {
+        const ret = wasm.identitypublickey_set_expires_at(this.__wbg_ptr, isLikeNone(expiresAt) ? 0 : addToExternrefTable0(expiresAt));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {boolean} isReadOnly
      */
@@ -10815,6 +11440,16 @@ export class IdentityPublicKey {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Setting a budget on a version 0 key makes it a version 1 key
+     * @param {bigint | null} [totalBudget]
+     */
+    set totalBudget(totalBudget) {
+        const ret = wasm.identitypublickey_set_total_budget(this.__wbg_ptr, isLikeNone(totalBudget) ? 0 : addToExternrefTable0(totalBudget));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {string}
      */
@@ -10873,6 +11508,14 @@ export class IdentityPublicKey {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The total credits the key may spend over its lifetime, `undefined` when it has no budget
+     * @returns {bigint | undefined}
+     */
+    get totalBudget() {
+        const ret = wasm.identitypublickey_total_budget(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @returns {string}
      */
@@ -10951,6 +11594,15 @@ export class IdentityPublicKeyInCreation {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * The block time in milliseconds from which the key can no longer sign, `undefined` when
+     * it does not expire
+     * @returns {bigint | undefined}
+     */
+    get expiresAt() {
+        const ret = wasm.identitypublickeyincreation_expires_at(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @param {IdentityPublicKeyInCreationJSON} js
      * @returns {IdentityPublicKeyInCreation}
@@ -11063,6 +11715,17 @@ export class IdentityPublicKeyInCreation {
         const len0 = WASM_VECTOR_LEN;
         wasm.identitypublickeyincreation_set_data(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Setting an expiry on a version 0 key makes it a version 1 key. The key's own signature
+     * no longer covers it afterwards: sign again.
+     * @param {bigint | null} [expiresAt]
+     */
+    set expiresAt(expiresAt) {
+        const ret = wasm.identitypublickeyincreation_set_expires_at(this.__wbg_ptr, isLikeNone(expiresAt) ? 0 : addToExternrefTable0(expiresAt));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {boolean} isReadOnly
      */
@@ -11113,6 +11776,17 @@ export class IdentityPublicKeyInCreation {
         const len0 = WASM_VECTOR_LEN;
         wasm.identitypublickeyincreation_set_signature(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Setting a budget on a version 0 key makes it a version 1 key. The key's own signature
+     * no longer covers it afterwards: sign again.
+     * @param {bigint | null} [totalBudget]
+     */
+    set totalBudget(totalBudget) {
+        const ret = wasm.identitypublickeyincreation_set_total_budget(this.__wbg_ptr, isLikeNone(totalBudget) ? 0 : addToExternrefTable0(totalBudget));
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {Uint8Array}
      */
@@ -11164,6 +11838,14 @@ export class IdentityPublicKeyInCreation {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The credits the key may spend over its lifetime, `undefined` when it has no budget
+     * @returns {bigint | undefined}
+     */
+    get totalBudget() {
+        const ret = wasm.identitypublickeyincreation_total_budget(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
     /**
      * @returns {string}
      */
@@ -11456,54 +12138,334 @@ export class IdentityTopUpFromAddressesTransition {
         return v1;
     }
     /**
-     * @returns {PlatformAddressOutput | undefined}
+     * @returns {PlatformAddressOutput | undefined}
+     */
+    get output() {
+        const ret = wasm.identitytopupfromaddressestransition_output(this.__wbg_ptr);
+        return ret === 0 ? undefined : PlatformAddressOutput.__wrap(ret);
+    }
+    /**
+     * @param {IdentifierLike} identityId
+     */
+    set identityId(identityId) {
+        const ret = wasm.identitytopupfromaddressestransition_set_identity_id(this.__wbg_ptr, identityId);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {PlatformAddressInput[]} inputs
+     */
+    set inputs(inputs) {
+        const ptr0 = passArrayJsValueToWasm0(inputs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitytopupfromaddressestransition_set_inputs(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {PlatformAddressOutput | null} [output]
+     */
+    set output(output) {
+        let ptr0 = 0;
+        if (!isLikeNone(output)) {
+            _assertClass(output, PlatformAddressOutput);
+            ptr0 = output.__destroy_into_raw();
+        }
+        const ret = wasm.identitytopupfromaddressestransition_set_output(this.__wbg_ptr, ptr0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} userFeeIncrease
+     */
+    set userFeeIncrease(userFeeIncrease) {
+        const ret = wasm.identitytopupfromaddressestransition_set_user_fee_increase(this.__wbg_ptr, userFeeIncrease);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitytopupfromaddressestransition_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.identitytopupfromaddressestransition_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.identitytopupfromaddressestransition_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.identitytopupfromaddressestransition_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 {IdentityTopUpFromAddressesTransitionJSON}
+     */
+    toJSON() {
+        const ret = wasm.identitytopupfromaddressestransition_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {IdentityTopUpFromAddressesTransitionObject}
+     */
+    toObject() {
+        const ret = wasm.identitytopupfromaddressestransition_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.identitytopupfromaddressestransition_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitytopupfromaddressestransition_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.identitytopupfromaddressestransition_user_fee_increase(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) IdentityTopUpFromAddressesTransition.prototype[Symbol.dispose] = IdentityTopUpFromAddressesTransition.prototype.free;
+
+export class IdentityTopUpFromShieldedPoolTransition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityTopUpFromShieldedPoolTransition.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityTopUpFromShieldedPoolTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityTopUpFromShieldedPoolTransitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitytopupfromshieldedpooltransition_free(ptr, 0);
+    }
+    /**
+     * Returns the serialized Orchard actions.
+     * @returns {SerializedOrchardAction[]}
+     */
+    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;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    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 {IdentityTopUpFromShieldedPoolTransition}
+     */
+    static fromBase64(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromBase64(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} hex
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
+     */
+    static fromHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromHex(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityTopUpFromShieldedPoolTransitionJSON} js
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
+     */
+    static fromJSON(js) {
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityTopUpFromShieldedPoolTransitionObject} obj
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
+     */
+    static fromObject(obj) {
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {StateTransition} st
+     * @returns {IdentityTopUpFromShieldedPoolTransition}
      */
-    get output() {
-        const ret = wasm.identitytopupfromaddressestransition_output(this.__wbg_ptr);
-        return ret === 0 ? undefined : PlatformAddressOutput.__wrap(ret);
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransition);
+        const ret = wasm.identitytopupfromshieldedpooltransition_fromStateTransition(st.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityTopUpFromShieldedPoolTransition.__wrap(ret[0]);
     }
     /**
-     * @param {IdentifierLike} identityId
+     * @returns {Identifier[]}
      */
-    set identityId(identityId) {
-        const ret = wasm.identitytopupfromaddressestransition_set_identity_id(this.__wbg_ptr, identityId);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    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;
     }
     /**
-     * @param {PlatformAddressInput[]} inputs
+     * 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 inputs(inputs) {
-        const ptr0 = passArrayJsValueToWasm0(inputs, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.identitytopupfromaddressestransition_set_inputs(this.__wbg_ptr, ptr0, len0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    get identityId() {
+        const ret = wasm.identitytopupfromshieldedpooltransition_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
-     * @param {PlatformAddressOutput | null} [output]
+     * @param {IdentityTopUpFromShieldedPoolTransitionOptions} options
      */
-    set output(output) {
-        let ptr0 = 0;
-        if (!isLikeNone(output)) {
-            _assertClass(output, PlatformAddressOutput);
-            ptr0 = output.__destroy_into_raw();
-        }
-        const ret = wasm.identitytopupfromaddressestransition_set_output(this.__wbg_ptr, ptr0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    constructor(options) {
+        const ret = wasm.identitytopupfromshieldedpooltransition_new(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityTopUpFromShieldedPoolTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * @param {number} userFeeIncrease
+     * @returns {Uint8Array}
      */
-    set userFeeIncrease(userFeeIncrease) {
-        const ret = wasm.identitytopupfromaddressestransition_set_user_fee_increase(this.__wbg_ptr, userFeeIncrease);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    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;
     }
     /**
      * @returns {string}
@@ -11512,7 +12474,7 @@ export class IdentityTopUpFromAddressesTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.identitytopupfromaddressestransition_struct_name();
+            const ret = wasm.identitytopupfromshieldedpooltransition_struct_name();
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -11527,7 +12489,7 @@ export class IdentityTopUpFromAddressesTransition {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.identitytopupfromaddressestransition_toBase64(this.__wbg_ptr);
+            const ret = wasm.identitytopupfromshieldedpooltransition_toBase64(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -11545,7 +12507,7 @@ export class IdentityTopUpFromAddressesTransition {
      * @returns {Uint8Array}
      */
     toBytes() {
-        const ret = wasm.identitytopupfromaddressestransition_toBytes(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toBytes(this.__wbg_ptr);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -11560,7 +12522,7 @@ export class IdentityTopUpFromAddressesTransition {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.identitytopupfromaddressestransition_toHex(this.__wbg_ptr);
+            const ret = wasm.identitytopupfromshieldedpooltransition_toHex(this.__wbg_ptr);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -11575,20 +12537,20 @@ export class IdentityTopUpFromAddressesTransition {
         }
     }
     /**
-     * @returns {IdentityTopUpFromAddressesTransitionJSON}
+     * @returns {IdentityTopUpFromShieldedPoolTransitionJSON}
      */
     toJSON() {
-        const ret = wasm.identitytopupfromaddressestransition_toJSON(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toJSON(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {IdentityTopUpFromAddressesTransitionObject}
+     * @returns {IdentityTopUpFromShieldedPoolTransitionObject}
      */
     toObject() {
-        const ret = wasm.identitytopupfromaddressestransition_toObject(this.__wbg_ptr);
+        const ret = wasm.identitytopupfromshieldedpooltransition_toObject(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -11598,9 +12560,17 @@ export class IdentityTopUpFromAddressesTransition {
      * @returns {StateTransition}
      */
     toStateTransition() {
-        const ret = wasm.identitytopupfromaddressestransition_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}
      */
@@ -11608,7 +12578,7 @@ export class IdentityTopUpFromAddressesTransition {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.identitytopupfromaddressestransition_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]);
@@ -11616,15 +12586,8 @@ export class IdentityTopUpFromAddressesTransition {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @returns {number}
-     */
-    get userFeeIncrease() {
-        const ret = wasm.identitytopupfromaddressestransition_user_fee_increase(this.__wbg_ptr);
-        return ret;
-    }
 }
-if (Symbol.dispose) IdentityTopUpFromAddressesTransition.prototype[Symbol.dispose] = IdentityTopUpFromAddressesTransition.prototype.free;
+if (Symbol.dispose) IdentityTopUpFromShieldedPoolTransition.prototype[Symbol.dispose] = IdentityTopUpFromShieldedPoolTransition.prototype.free;
 
 export class IdentityTopUpTransition {
     static __wrap(ptr) {
@@ -14957,7 +15920,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 +15966,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 +16148,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 +16203,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 +16212,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 +16464,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 +16473,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 +16506,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 +16550,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 +16560,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 +16569,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 +19488,7 @@ export class TokenDistributionRecipient {
      * @returns {TokenDistributionRecipient}
      */
     static ContractOwner() {
-        const ret = wasm.authorizedactiontakers_NoOne();
+        const ret = wasm.tokendistributionrecipient_ContractOwner();
         return TokenDistributionRecipient.__wrap(ret);
     }
     /**
@@ -21380,7 +22699,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 +22816,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>}
@@ -24459,7 +25778,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 +26175,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')
@@ -25028,6 +26347,9 @@ const IdentityCreditTransferToAddressesFinalization = (typeof FinalizationRegist
 const IdentityCreditWithdrawalTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitycreditwithdrawaltransition_free(ptr >>> 0, 1));
+const IdentityKeyLimitsUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitykeylimitsupdate_free(ptr >>> 0, 1));
 const IdentityPublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitypublickey_free(ptr >>> 0, 1));
@@ -25043,6 +26365,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 +26434,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));