@dashevo/wasm-dpp2 4.0.0 → 4.1.0-beta.2

package/dist/raw/wasm_dpp2.no_url.js

@@ -1008,6 +1008,28 @@ export class AddressWitness {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_addresswitness_free(ptr, 0);
     }
+    /**
+     * @param {AddressWitnessJSON} js
+     * @returns {AddressWitness}
+     */
+    static fromJSON(js) {
+        const ret = wasm.addresswitness_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AddressWitness.__wrap(ret[0]);
+    }
+    /**
+     * @param {AddressWitnessObject} obj
+     * @returns {AddressWitness}
+     */
+    static fromObject(obj) {
+        const ret = wasm.addresswitness_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AddressWitness.__wrap(ret[0]);
+    }
     /**
      * Returns true if this is a P2PKH witness.
      * @returns {boolean}
@@ -1128,6 +1150,26 @@ export class AddressWitness {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {AddressWitnessJSON}
+     */
+    toJSON() {
+        const ret = wasm.addresswitness_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {AddressWitnessObject}
+     */
+    toObject() {
+        const ret = wasm.addresswitness_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @returns {string}
      */
@@ -1280,7 +1322,7 @@ export class AssetLockProof {
     }
     /**
      * Returns the lock type as a lowercase wire-shape string ("instant" or
-     * "chain") — matching the `type` discriminator emitted by `toObject()` /
+     * "chain") — matching the `$type` discriminator emitted by `toObject()` /
      * `toJSON()`.
      * @returns {string}
      */
@@ -1602,22 +1644,22 @@ export class BatchTransition {
         return BatchTransition.__wrap(ret[0]);
     }
     /**
-     * @param {BatchTransitionJSON} object
+     * @param {BatchTransitionJSON} js
      * @returns {BatchTransition}
      */
-    static fromJSON(object) {
-        const ret = wasm.batchtransition_fromJSON(object);
+    static fromJSON(js) {
+        const ret = wasm.batchtransition_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return BatchTransition.__wrap(ret[0]);
     }
     /**
-     * @param {BatchTransitionObject} object
+     * @param {BatchTransitionObject} obj
      * @returns {BatchTransition}
      */
-    static fromObject(object) {
-        const ret = wasm.batchtransition_fromObject(object);
+    static fromObject(obj) {
+        const ret = wasm.batchtransition_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -5322,27 +5364,27 @@ export class Document {
         return Document.__wrap(ret[0]);
     }
     /**
-     * Create a Document from a JSON object.
+     * Create a Document from a JSON object (canonical-tagged shape).
      * JSON format has identifiers as base58 strings.
      * @param {DocumentJSON} value
-     * @param {PlatformVersionLike} platform_version
+     * @param {PlatformVersionLike} _platform_version
      * @returns {Document}
      */
-    static fromJSON(value, platform_version) {
-        const ret = wasm.document_fromJSON(value, platform_version);
+    static fromJSON(value, _platform_version) {
+        const ret = wasm.document_fromJSON(value, _platform_version);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Document.__wrap(ret[0]);
     }
     /**
-     * Create a Document from a JS object.
+     * Create a Document from a JS object (canonical-tagged shape).
      * @param {DocumentObject} value
-     * @param {PlatformVersionLike} platform_version
+     * @param {PlatformVersionLike} _platform_version
      * @returns {Document}
      */
-    static fromObject(value, platform_version) {
-        const ret = wasm.document_fromObject(value, platform_version);
+    static fromObject(value, _platform_version) {
+        const ret = wasm.document_fromObject(value, _platform_version);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -5594,11 +5636,11 @@ export class Document {
     }
     /**
      * Convert to a JSON-compatible JS object with binary fields as strings.
-     * @param {PlatformVersionLike} platform_version
+     * @param {PlatformVersionLike} _platform_version
      * @returns {DocumentJSON}
      */
-    toJSON(platform_version) {
-        const ret = wasm.document_toJSON(this.__wbg_ptr, platform_version);
+    toJSON(_platform_version) {
+        const ret = wasm.document_toJSON(this.__wbg_ptr, _platform_version);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -5606,6 +5648,12 @@ export class Document {
     }
     /**
      * Convert to a JS object with binary fields as Uint8Array.
+     *
+     * Wire shape (Phase D step 8 slice B):
+     * - `$formatVersion: "0"` — canonical Document version tag
+     * - `$dataContractId`, `$type`, `$entropy` — wasm-side metadata
+     * - V0 Document fields (`$id`, `$ownerId`, `$revision`, …) flat
+     *   alongside user-defined properties
      * @returns {DocumentObject}
      */
     toObject() {
@@ -7060,7 +7108,7 @@ if (Symbol.dispose) ExtendedEpochInfo.prototype[Symbol.dispose] = ExtendedEpochI
  * should be reduced to cover the transaction fee.
  *
  * `#[serde(transparent)]` delegates to the inner `AddressFundsFeeStrategyStep`'s
- * custom serde, which produces the `{ type, index }` adjacent shape used by
+ * custom serde, which produces the `{ $type, index }` adjacent shape used by
  * every wasm-sdk consumer that round-trips a `Vec<FeeStrategyStepWasm>`.
  */
 export class FeeStrategyStep {
@@ -7476,22 +7524,22 @@ export class Group {
         return this;
     }
     /**
-     * @param {GroupJSON} object
+     * @param {GroupJSON} js
      * @returns {Group}
      */
-    static fromJSON(object) {
-        const ret = wasm.group_fromJSON(object);
+    static fromJSON(js) {
+        const ret = wasm.group_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Group.__wrap(ret[0]);
     }
     /**
-     * @param {GroupObject} value
+     * @param {GroupObject} obj
      * @returns {Group}
      */
-    static fromObject(value) {
-        const ret = wasm.group_fromObject(value);
+    static fromObject(obj) {
+        const ret = wasm.group_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -8382,6 +8430,11 @@ export class Identity {
         return Identity.__wrap(ret[0]);
     }
     /**
+     * `fromObject` keeps the manual path because the wasm API dispatches on
+     * the `platform_version` arg (via `try_from_platform_versioned`) rather
+     * than the value's embedded `$formatVersion` tag — explicit version
+     * coupling is the wasm SDK convention. The canonical
+     * `ValueConvertible::from_object` would dispatch on the tag.
      * @param {IdentityObject} value
      * @param {PlatformVersionLike} platform_version
      * @returns {Identity}
@@ -8850,6 +8903,227 @@ export class IdentityCreateFromAddressesTransition {
 }
 if (Symbol.dispose) IdentityCreateFromAddressesTransition.prototype[Symbol.dispose] = IdentityCreateFromAddressesTransition.prototype.free;
 
+export class IdentityCreateFromShieldedPoolTransition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityCreateFromShieldedPoolTransition.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityCreateFromShieldedPoolTransitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityCreateFromShieldedPoolTransitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitycreatefromshieldedpooltransition_free(ptr, 0);
+    }
+    /**
+     * Returns the serialized Orchard actions.
+     * @returns {SerializedOrchardAction[]}
+     */
+    get actions() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_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.identitycreatefromshieldedpooltransition_anchor(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns the RedPallas binding signature (64 bytes).
+     * @returns {Uint8Array}
+     */
+    get bindingSignature() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_binding_signature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns the fixed exit denomination (credits leaving the shielded pool).
+     * @returns {bigint}
+     */
+    get denomination() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_denomination(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {IdentityCreateFromShieldedPoolTransition}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitycreatefromshieldedpooltransition_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityCreateFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityCreateFromShieldedPoolTransitionJSON} js
+     * @returns {IdentityCreateFromShieldedPoolTransition}
+     */
+    static fromJSON(js) {
+        const ret = wasm.identitycreatefromshieldedpooltransition_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityCreateFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @param {IdentityCreateFromShieldedPoolTransitionObject} obj
+     * @returns {IdentityCreateFromShieldedPoolTransition}
+     */
+    static fromObject(obj) {
+        const ret = wasm.identitycreatefromshieldedpooltransition_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityCreateFromShieldedPoolTransition.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Identifier[]}
+     */
+    getModifiedDataIds() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_getModifiedDataIds(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns the new identity's id (derived from the spend nullifiers).
+     * @returns {Identifier}
+     */
+    get identityId() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_identity_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @param {IdentityCreateFromShieldedPoolTransitionOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.identitycreatefromshieldedpooltransition_new(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityCreateFromShieldedPoolTransitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the Halo2 proof bytes.
+     * @returns {Uint8Array}
+     */
+    get proof() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_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 public keys of the new identity.
+     * @returns {IdentityPublicKeyInCreation[]}
+     */
+    get publicKeys() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_public_keys(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns the fallback platform address credited if identity creation
+     * fails a stateful check.
+     * @returns {PlatformAddress}
+     */
+    get sendToAddressOnCreationFailure() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_send_to_address_on_creation_failure(this.__wbg_ptr);
+        return PlatformAddress.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitycreatefromshieldedpooltransition_struct_name();
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_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 {IdentityCreateFromShieldedPoolTransitionJSON}
+     */
+    toJSON() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {IdentityCreateFromShieldedPoolTransitionObject}
+     */
+    toObject() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateTransition}
+     */
+    toStateTransition() {
+        const ret = wasm.identitycreatefromshieldedpooltransition_toStateTransition(this.__wbg_ptr);
+        return StateTransition.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitycreatefromshieldedpooltransition_type_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) IdentityCreateFromShieldedPoolTransition.prototype[Symbol.dispose] = IdentityCreateFromShieldedPoolTransition.prototype.free;
+
 export class IdentityCreateTransition {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -10314,16 +10588,18 @@ export class IdentityPublicKey {
         return IdentityPublicKey.__wrap(ret[0]);
     }
     /**
-     * Deserialize from JSON-compatible JS object (human-readable).
+     * Deserialize from JSON-compatible JS object (canonical wire shape).
      *
-     * Uses serde_json conversion which properly handles the tagged enum
-     * and deserializes base64 strings to binary data.
+     * 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
+     * @param {PlatformVersionLike} _platform_version
      * @returns {IdentityPublicKey}
      */
-    static fromJSON(value, platform_version) {
-        const ret = wasm.identitypublickey_fromJSON(value, platform_version);
+    static fromJSON(value, _platform_version) {
+        const ret = wasm.identitypublickey_fromJSON(value, _platform_version);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -10333,12 +10609,16 @@ export class IdentityPublicKey {
      * 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
+     * @param {PlatformVersionLike} _platform_version
      * @returns {IdentityPublicKey}
      */
-    static fromObject(value, platform_version) {
-        const ret = wasm.identitypublickey_fromObject(value, platform_version);
+    static fromObject(value, _platform_version) {
+        const ret = wasm.identitypublickey_fromObject(value, _platform_version);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -10563,10 +10843,12 @@ export class IdentityPublicKey {
         return v1;
     }
     /**
-     * Serialize to JSON-compatible JS object (human-readable).
+     * Serialize to JSON-compatible JS object (canonical wire shape).
      *
-     * Uses serde_json conversion which properly handles the tagged enum
-     * and serializes binary data as base64 strings.
+     * Binary fields render as base64 strings. Identifier fields render
+     * as base58 strings. This matches the canonical `JsonConvertible`
+     * path used by every other rs-dpp type's JSON conversion in this
+     * SDK — including `IdentityWasm.toJSON`'s embedded public keys.
      * @returns {IdentityPublicKeyJSON}
      */
     toJSON() {
@@ -10579,8 +10861,9 @@ export class IdentityPublicKey {
     /**
      * Serialize to JS object (non-human-readable).
      *
-     * Uses platform_value conversion which properly handles the tagged enum
-     * and removes None fields like disabledAt.
+     * Uses platform_value conversion which properly handles the tagged enum.
+     * `disabledAt: null` is stripped automatically by the
+     * `skip_serializing_if` attribute on the rs-dpp side.
      * @returns {IdentityPublicKeyObject}
      */
     toObject() {
@@ -14674,7 +14957,7 @@ export class SharedEncryptedNote {
     constructor(senderKeyIndex, recipientKeyIndex, value) {
         const ptr0 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sharedencryptednote_constructor(senderKeyIndex, recipientKeyIndex, ptr0, len0);
+        const ret = wasm.privateencryptednote_constructor(senderKeyIndex, recipientKeyIndex, ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
         SharedEncryptedNoteFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -17406,22 +17689,22 @@ export class TokenConfigurationLocalization {
         return this;
     }
     /**
-     * @param {TokenConfigurationLocalizationJSON} value
+     * @param {TokenConfigurationLocalizationJSON} js
      * @returns {TokenConfigurationLocalization}
      */
-    static fromJSON(value) {
-        const ret = wasm.tokenconfigurationlocalization_fromJSON(value);
+    static fromJSON(js) {
+        const ret = wasm.tokenconfigurationlocalization_fromJSON(js);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return TokenConfigurationLocalization.__wrap(ret[0]);
     }
     /**
-     * @param {TokenConfigurationLocalizationObject} value
+     * @param {TokenConfigurationLocalizationObject} obj
      * @returns {TokenConfigurationLocalization}
      */
-    static fromObject(value) {
-        const ret = wasm.tokenconfigurationlocalization_fromObject(value);
+    static fromObject(obj) {
+        const ret = wasm.tokenconfigurationlocalization_fromObject(obj);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -17886,7 +18169,7 @@ export class TokenDistributionRecipient {
      * @returns {TokenDistributionRecipient}
      */
     static ContractOwner() {
-        const ret = wasm.tokendistributionrecipient_ContractOwner();
+        const ret = wasm.authorizedactiontakers_NoOne();
         return TokenDistributionRecipient.__wrap(ret);
     }
     /**
@@ -19274,6 +19557,28 @@ export class TokenPricingSchedule {
         const ret = wasm.tokenpricingschedule_SinglePrice(credits);
         return TokenPricingSchedule.__wrap(ret);
     }
+    /**
+     * @param {any} js
+     * @returns {TokenPricingSchedule}
+     */
+    static fromJSON(js) {
+        const ret = wasm.tokenpricingschedule_fromJSON(js);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TokenPricingSchedule.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} obj
+     * @returns {TokenPricingSchedule}
+     */
+    static fromObject(obj) {
+        const ret = wasm.tokenpricingschedule_fromObject(obj);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TokenPricingSchedule.__wrap(ret[0]);
+    }
     /**
      * @returns {string}
      */
@@ -19304,6 +19609,26 @@ export class TokenPricingSchedule {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.tokenpricingschedule_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    toObject() {
+        const ret = wasm.tokenpricingschedule_toObject(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @returns {string}
      */
@@ -24688,6 +25013,9 @@ const IdentityFinalization = (typeof FinalizationRegistry === 'undefined')
 const IdentityCreateFromAddressesTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitycreatefromaddressestransition_free(ptr >>> 0, 1));
+const IdentityCreateFromShieldedPoolTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitycreatefromshieldedpooltransition_free(ptr >>> 0, 1));
 const IdentityCreateTransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitycreatetransition_free(ptr >>> 0, 1));