@dashevo/wasm-dpp2 3.0.0-dev.9 → 3.0.0-rc.2

package/dist/raw/wasm_dpp2.js

@@ -184,6 +184,35 @@ function debugString(val) {
     return className;
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * Test helper: Convert a JsValue to a JSON-compatible JsValue.
+ *
+ * This function is exposed for testing purposes to validate the Map normalization
+ * and BigInt handling logic in unit tests. It calls `js_value_to_json` internally
+ * and converts the result back to a JsValue.
+ *
+ * # Example (JavaScript)
+ * ```javascript
+ * const map = new Map([['key', 'value']]);
+ * const json = testJsValueToJson(map);
+ * console.log(json); // { key: 'value' }
+ * ```
+ * @param {any} value
+ * @returns {any}
+ */
+export function testJsValueToJson(value) {
+    const ret = wasm.testJsValueToJson(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -191,12 +220,6 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -234,6 +257,10 @@ function passArray32ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+function __wbg_adapter_1538(arg0, arg1, arg2, arg3) {
+    wasm.closure1353_externref_shim(arg0, arg1, arg2, arg3);
+}
+
 /**
  * @enum {0 | 1}
  */
@@ -7327,6 +7354,135 @@ export class GroupStateTransitionInfo {
     }
 }
 
+const GroupStateTransitionInfoStatusFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_groupstatetransitioninfostatus_free(ptr >>> 0, 1));
+/**
+ * Wrapper for GroupStateTransitionInfoStatus enum.
+ *
+ * This represents the group action context for a state transition:
+ * - Proposer: The identity proposing a new group action
+ * - OtherSigner: The identity signing/voting on an existing group action
+ */
+export class GroupStateTransitionInfoStatus {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GroupStateTransitionInfoStatus.prototype);
+        obj.__wbg_ptr = ptr;
+        GroupStateTransitionInfoStatusFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GroupStateTransitionInfoStatusFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_groupstatetransitioninfostatus_free(ptr, 0);
+    }
+    /**
+     * Check if this is a proposer status.
+     * @returns {boolean}
+     */
+    get isProposer() {
+        const ret = wasm.groupstatetransitioninfostatus_is_proposer(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.groupstatetransitioninfostatus_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);
+        }
+    }
+    /**
+     * Create a new other signer status for voting on an existing group action.
+     *
+     * Use this when the identity is signing/voting on an action proposed by someone else.
+     *
+     * @param groupContractPosition - The position of the group in the contract
+     * @param actionId - The ID of the action being voted on
+     * @returns GroupStateTransitionInfoStatus for an other signer
+     * @param {number} group_contract_position
+     * @param {Identifier | Uint8Array | string} action_id
+     * @returns {GroupStateTransitionInfoStatus}
+     */
+    static otherSigner(group_contract_position, action_id) {
+        const ret = wasm.groupstatetransitioninfostatus_otherSigner(group_contract_position, action_id);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GroupStateTransitionInfoStatus.__wrap(ret[0]);
+    }
+    /**
+     * Get the group contract position.
+     * @returns {number}
+     */
+    get groupContractPosition() {
+        const ret = wasm.groupstatetransitioninfostatus_group_contract_position(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Convert to GroupStateTransitionInfo.
+     * @returns {GroupStateTransitionInfo}
+     */
+    toInfo() {
+        const ret = wasm.groupstatetransitioninfostatus_toInfo(this.__wbg_ptr);
+        return GroupStateTransitionInfo.__wrap(ret);
+    }
+    /**
+     * Create a new proposer status for initiating a group action.
+     *
+     * Use this when the identity is proposing a new group action.
+     *
+     * @param groupContractPosition - The position of the group in the contract
+     * @returns GroupStateTransitionInfoStatus for a proposer
+     * @param {number} group_contract_position
+     * @returns {GroupStateTransitionInfoStatus}
+     */
+    static proposer(group_contract_position) {
+        const ret = wasm.groupstatetransitioninfostatus_proposer(group_contract_position);
+        return GroupStateTransitionInfoStatus.__wrap(ret);
+    }
+    /**
+     * Get the action ID (only available for other signer status).
+     * Returns null for proposer status.
+     * @returns {Identifier | undefined}
+     */
+    get actionId() {
+        const ret = wasm.groupstatetransitioninfostatus_action_id(this.__wbg_ptr);
+        return ret === 0 ? undefined : Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.groupstatetransitioninfostatus_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);
+        }
+    }
+}
+
 const IdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identifier_free(ptr >>> 0, 1));
@@ -9147,7 +9303,7 @@ export class IdentityPublicKey {
     }
     /**
      * @param {Uint8Array} js_private_key_bytes
-     * @param {Network | string} network
+     * @param {NetworkLike} network
      * @returns {boolean}
      */
     validatePrivateKey(js_private_key_bytes, network) {
@@ -9654,8 +9810,8 @@ const IdentitySignerFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
  * A signer for identity-based state transitions.
  *
- * This signer holds private keys mapped by their public key hash (for ECDSA_HASH160 keys)
- * and can sign state transitions that require identity keys.
+ * Private keys are stored by their public key hash (20 bytes).
+ * Both ECDSA_HASH160 and ECDSA_SECP256K1 keys are looked up by hash160.
  */
 export class IdentitySigner {
 
@@ -9711,8 +9867,7 @@ export class IdentitySigner {
     /**
      * Adds a private key to the signer.
      *
-     * The public key hash is derived automatically from the private key using
-     * Hash160(compressed_public_key) where Hash160 = RIPEMD160(SHA256(x)).
+     * The key is stored by public key hash (20 bytes): Hash160(compressed_public_key)
      *
      * @param privateKey - The PrivateKey object
      * @param {PrivateKey} private_key
@@ -9732,6 +9887,21 @@ export class IdentitySigner {
         const ret = wasm.identitysigner_key_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitysigner_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);
+        }
+    }
 }
 
 const IdentityTokenInfoFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -11355,29 +11525,25 @@ export class PlatformAddress {
     }
     /**
      * Returns the bech32m-encoded address string for the specified network.
-     *
-     * @param network - "mainnet", "testnet", "devnet", or "regtest"
-     * @param {string} network
+     * @param {NetworkLike} network
      * @returns {string}
      */
     toBech32m(network) {
-        let deferred3_0;
-        let deferred3_1;
-        try {
-            const ptr0 = passStringToWasm0(network, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.platformaddress_toBech32m(this.__wbg_ptr, ptr0, len0);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.platformaddress_toBech32m(this.__wbg_ptr, network);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
             if (ret[3]) {
-                ptr2 = 0; len2 = 0;
+                ptr1 = 0; len1 = 0;
                 throw takeFromExternrefTable0(ret[2]);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
     /**
@@ -11750,7 +11916,7 @@ export class PlatformAddressSigner {
      * Creates a new empty PlatformAddressSigner.
      */
     constructor() {
-        const ret = wasm.identitysigner_new();
+        const ret = wasm.platformaddresssigner_new();
         this.__wbg_ptr = ret >>> 0;
         PlatformAddressSignerFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -11793,6 +11959,22 @@ export class PlatformAddressSigner {
         const ret = wasm.platformaddresssigner_key_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Returns the type name for WASM object identification (instance getter).
+     * @returns {string}
+     */
+    get __type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.platformaddresssigner_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);
+        }
+    }
 }
 
 const PrefundedVotingBalanceFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -12158,6 +12340,25 @@ export class PrivateKey {
     }
 }
 
+const ProTxHashFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_protxhash_free(ptr >>> 0, 1));
+
+export class ProTxHash {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProTxHashFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_protxhash_free(ptr, 0);
+    }
+}
+
 const PublicKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_publickey_free(ptr >>> 0, 1));
@@ -12512,7 +12713,7 @@ export class ResourceVoteChoice {
      * @returns {ResourceVoteChoice}
      */
     static Abstain() {
-        const ret = wasm.resourcevotechoice_Abstain();
+        const ret = wasm.authorizedactiontakers_ContractOwner();
         return ResourceVoteChoice.__wrap(ret);
     }
     /**
@@ -14143,6 +14344,21 @@ export class TokenConfigurationChangeItem {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_tokenconfigurationchangeitem_free(ptr, 0);
     }
+    /**
+     * @param {number | null} [group_contract_position]
+     * @returns {TokenConfigurationChangeItem}
+     */
+    static MainControlGroupItem(group_contract_position) {
+        const ret = wasm.tokenconfigurationchangeitem_MainControlGroupItem(isLikeNone(group_contract_position) ? 0xFFFFFF : group_contract_position);
+        return TokenConfigurationChangeItem.__wrap(ret);
+    }
+    /**
+     * @returns {TokenConfigurationChangeItem}
+     */
+    static noChangeItem() {
+        const ret = wasm.tokenconfigurationchangeitem_noChangeItem();
+        return TokenConfigurationChangeItem.__wrap(ret);
+    }
     /**
      * @param {bigint | null} [supply]
      * @returns {TokenConfigurationChangeItem}
@@ -14322,101 +14538,94 @@ export class TokenConfigurationChangeItem {
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
-     * @param {boolean} flag
+     * @param {Identifier | Uint8Array | string} js_identity_id
      * @returns {TokenConfigurationChangeItem}
      */
-    static MintingAllowChoosingDestinationItem(flag) {
-        const ret = wasm.tokenconfigurationchangeitem_MintingAllowChoosingDestinationItem(flag);
-        return TokenConfigurationChangeItem.__wrap(ret);
+    static NewTokensDestinationIdentityItem(js_identity_id) {
+        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityItem(js_identity_id);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TokenConfigurationChangeItem.__wrap(ret[0]);
     }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static MintingAllowChoosingDestinationAdminGroupItem(action_taker) {
+    static NewTokensDestinationIdentityAdminGroupItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_MintingAllowChoosingDestinationAdminGroupItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityAdminGroupItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static MintingAllowChoosingDestinationControlGroupItem(action_taker) {
+    static NewTokensDestinationIdentityControlGroupItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_MintingAllowChoosingDestinationControlGroupItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityControlGroupItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
-     * @param {AuthorizedActionTakers} action_taker
+     * @param {boolean} flag
      * @returns {TokenConfigurationChangeItem}
      */
-    static FreezeItem(action_taker) {
-        _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_FreezeItem(action_taker.__wbg_ptr);
+    static MintingAllowChoosingDestinationItem(flag) {
+        const ret = wasm.tokenconfigurationchangeitem_MintingAllowChoosingDestinationItem(flag);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static FreezeAdminGroupItem(action_taker) {
+    static MintingAllowChoosingDestinationAdminGroupItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_FreezeAdminGroupItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_MintingAllowChoosingDestinationAdminGroupItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static UnfreezeItem(action_taker) {
+    static MintingAllowChoosingDestinationControlGroupItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_UnfreezeItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_MintingAllowChoosingDestinationControlGroupItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static UnfreezeAdminGroupItem(action_taker) {
+    static FreezeItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_UnfreezeAdminGroupItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_FreezeItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
-    /**
-     * @param {Identifier | Uint8Array | string} js_identity_id
-     * @returns {TokenConfigurationChangeItem}
-     */
-    static NewTokensDestinationIdentityItem(js_identity_id) {
-        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityItem(js_identity_id);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return TokenConfigurationChangeItem.__wrap(ret[0]);
-    }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static NewTokensDestinationIdentityAdminGroupItem(action_taker) {
+    static FreezeAdminGroupItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityAdminGroupItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_FreezeAdminGroupItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
      * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static NewTokensDestinationIdentityControlGroupItem(action_taker) {
+    static UnfreezeItem(action_taker) {
         _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityControlGroupItem(action_taker.__wbg_ptr);
+        const ret = wasm.tokenconfigurationchangeitem_UnfreezeItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
+     * @param {AuthorizedActionTakers} action_taker
      * @returns {TokenConfigurationChangeItem}
      */
-    static noChangeItem() {
-        const ret = wasm.tokenconfigurationchangeitem_noChangeItem();
+    static UnfreezeAdminGroupItem(action_taker) {
+        _assertClass(action_taker, AuthorizedActionTakers);
+        const ret = wasm.tokenconfigurationchangeitem_UnfreezeAdminGroupItem(action_taker.__wbg_ptr);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
@@ -14471,14 +14680,6 @@ export class TokenConfigurationChangeItem {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @param {number | null} [group_contract_position]
-     * @returns {TokenConfigurationChangeItem}
-     */
-    static MainControlGroupItem(group_contract_position) {
-        const ret = wasm.tokenconfigurationchangeitem_MainControlGroupItem(isLikeNone(group_contract_position) ? 0xFFFFFF : group_contract_position);
-        return TokenConfigurationChangeItem.__wrap(ret);
-    }
 }
 
 const TokenConfigurationConventionFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -17786,6 +17987,23 @@ function __wbg_get_imports() {
         const ret = EpochBasedDistribution.__wrap(arg0);
         return ret;
     };
+    imports.wbg.__wbg_forEach_d3693088122c0e7b = function(arg0, arg1, arg2) {
+        try {
+            var state0 = {a: arg1, b: arg2};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_1538(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            arg0.forEach(cb0);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
     imports.wbg.__wbg_from_237b1ad767238d8b = function(arg0) {
         const ret = Array.from(arg0);
         return ret;
@@ -17841,6 +18059,16 @@ function __wbg_get_imports() {
         const ret = result;
         return ret;
     };
+    imports.wbg.__wbg_instanceof_Map_dd89a82d76d1b25f = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Map;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_instanceof_Uint8Array_91f3c5adee7e6672 = function(arg0) {
         let result;
         try {
@@ -17998,6 +18226,10 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg_toString_349e2a4aa036ef9c = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.toString(arg1);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_toString_83737cbd5ac9f7a7 = function() { return handleError(function (arg0, arg1) {
         const ret = arg0.toString(arg1);
         return ret;