@dashevo/wasm-dpp2 3.0.0-dev.6 → 3.0.0-dev.8

package/dist/raw/wasm_dpp2.js

@@ -6420,6 +6420,88 @@ export class ExtendedEpochInfo {
     }
 }
 
+const FeeStrategyStepFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_feestrategystep_free(ptr >>> 0, 1));
+/**
+ * Defines how fees are paid in address-based state transitions.
+ *
+ * Fee strategy is a sequence of steps that determine which inputs or outputs
+ * should be reduced to cover the transaction fee.
+ */
+export class FeeStrategyStep {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(FeeStrategyStep.prototype);
+        obj.__wbg_ptr = ptr;
+        FeeStrategyStepFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FeeStrategyStepFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_feestrategystep_free(ptr, 0);
+    }
+    /**
+     * Creates a step that reduces the output at the given index by the fee amount.
+     *
+     * The output amount will be reduced to cover the fee.
+     *
+     * @param index - The index of the output address to reduce
+     * @param {number} index
+     * @returns {FeeStrategyStep}
+     */
+    static reduceOutput(index) {
+        const ret = wasm.feestrategystep_reduceOutput(index);
+        return FeeStrategyStep.__wrap(ret);
+    }
+    /**
+     * Returns true if this step reduces an output.
+     * @returns {boolean}
+     */
+    get isReduceOutput() {
+        const ret = wasm.feestrategystep_isReduceOutput(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Creates a step that deducts the fee from the input at the given index.
+     *
+     * The input must have remaining balance after its contribution to outputs.
+     *
+     * @param index - The index of the input address to deduct fee from
+     * @param {number} index
+     * @returns {FeeStrategyStep}
+     */
+    static deductFromInput(index) {
+        const ret = wasm.feestrategystep_deductFromInput(index);
+        return FeeStrategyStep.__wrap(ret);
+    }
+    /**
+     * Returns true if this step deducts from an input.
+     * @returns {boolean}
+     */
+    get isDeductFromInput() {
+        const ret = wasm.feestrategystep_isDeductFromInput(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns the index associated with this step.
+     * @returns {number}
+     */
+    get index() {
+        const ret = wasm.feestrategystep_index(this.__wbg_ptr);
+        return ret;
+    }
+}
+
 const FinalizedEpochInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_finalizedepochinfo_free(ptr >>> 0, 1));
@@ -7324,6 +7406,23 @@ export class Identifier {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Returns the identifier as a Base58 string.
+     * This is the default string representation for JavaScript.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identifier_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * @param {Identifier | Uint8Array | string} identifier
      */
@@ -7558,11 +7657,11 @@ export class Identity {
     }
     /**
      * @param {number} key_id
-     * @returns {IdentityPublicKey}
+     * @returns {IdentityPublicKey | undefined}
      */
     getPublicKeyById(key_id) {
         const ret = wasm.identity_getPublicKeyById(this.__wbg_ptr, key_id);
-        return IdentityPublicKey.__wrap(ret);
+        return ret === 0 ? undefined : IdentityPublicKey.__wrap(ret);
     }
     /**
      * @param {Identifier | Uint8Array | string} js_identifier
@@ -9549,6 +9648,92 @@ export class IdentityPublicKeyInCreation {
     }
 }
 
+const IdentitySignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitysigner_free(ptr >>> 0, 1));
+/**
+ * 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.
+ */
+export class IdentitySigner {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentitySignerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitysigner_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitysigner_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);
+        }
+    }
+    /**
+     * Adds a private key from WIF format.
+     *
+     * @param wif - The private key in WIF format
+     * @param {string} wif
+     */
+    addKeyFromWif(wif) {
+        const ptr0 = passStringToWasm0(wif, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitysigner_addKeyFromWif(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Creates a new empty IdentitySigner.
+     */
+    constructor() {
+        const ret = wasm.identitysigner_new();
+        this.__wbg_ptr = ret >>> 0;
+        IdentitySignerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * 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)).
+     *
+     * @param privateKey - The PrivateKey object
+     * @param {PrivateKey} private_key
+     */
+    addKey(private_key) {
+        _assertClass(private_key, PrivateKey);
+        const ret = wasm.identitysigner_addKey(this.__wbg_ptr, private_key.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Returns the number of keys in this signer.
+     * @returns {number}
+     */
+    get keyCount() {
+        const ret = wasm.identitysigner_key_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const IdentityTokenInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitytokeninfo_free(ptr >>> 0, 1));
@@ -11387,6 +11572,229 @@ export class PlatformAddress {
     }
 }
 
+const PlatformAddressInputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_platformaddressinput_free(ptr >>> 0, 1));
+/**
+ * Represents an input address for address-based state transitions.
+ *
+ * An input specifies a Platform address that will spend credits,
+ * along with its current nonce and the amount to spend.
+ */
+export class PlatformAddressInput {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PlatformAddressInputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_platformaddressinput_free(ptr, 0);
+    }
+    /**
+     * Creates a new PlatformAddressInput.
+     *
+     * @param address - The Platform address (PlatformAddress, Uint8Array, or bech32m string)
+     * @param nonce - The current nonce of the address (will be incremented for the transaction)
+     * @param amount - The amount of credits to spend from this address
+     * @param {PlatformAddressLike} address
+     * @param {number} nonce
+     * @param {bigint} amount
+     */
+    constructor(address, nonce, amount) {
+        const ret = wasm.platformaddressinput_new(address, nonce, amount);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PlatformAddressInputFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the nonce.
+     * @returns {number}
+     */
+    get nonce() {
+        const ret = wasm.platformaddressinput_nonce(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns the amount.
+     * @returns {bigint}
+     */
+    get amount() {
+        const ret = wasm.platformaddressinput_amount(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the Platform address.
+     * @returns {PlatformAddress}
+     */
+    get address() {
+        const ret = wasm.platformaddressinput_address(this.__wbg_ptr);
+        return PlatformAddress.__wrap(ret);
+    }
+}
+
+const PlatformAddressOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_platformaddressoutput_free(ptr >>> 0, 1));
+/**
+ * Represents an output address for address-based state transitions.
+ *
+ * An output specifies a Platform address that will receive credits,
+ * along with an optional amount to receive. When amount is None,
+ * the system distributes funds automatically (used for asset lock funding).
+ */
+export class PlatformAddressOutput {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PlatformAddressOutputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_platformaddressoutput_free(ptr, 0);
+    }
+    /**
+     * Creates a new PlatformAddressOutput with a specific amount.
+     *
+     * @param address - The Platform address (PlatformAddress, Uint8Array, or bech32m string)
+     * @param amount - The amount of credits to send to this address (optional for asset lock funding)
+     * @param {PlatformAddressLike} address
+     * @param {bigint | null} [amount]
+     */
+    constructor(address, amount) {
+        const ret = wasm.platformaddressoutput_new(address, isLikeNone(amount) ? 0 : addToExternrefTable0(amount));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PlatformAddressOutputFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the amount, or undefined if not specified.
+     * @returns {bigint | undefined}
+     */
+    get amount() {
+        const ret = wasm.platformaddressoutput_amount(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns the Platform address.
+     * @returns {PlatformAddress}
+     */
+    get address() {
+        const ret = wasm.platformaddressoutput_address(this.__wbg_ptr);
+        return PlatformAddress.__wrap(ret);
+    }
+}
+
+const PlatformAddressSignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_platformaddresssigner_free(ptr >>> 0, 1));
+/**
+ * A signer for Platform address-based state transitions.
+ *
+ * This signer holds private keys for Platform addresses and can sign
+ * state transitions that spend from those addresses.
+ */
+export class PlatformAddressSigner {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PlatformAddressSignerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_platformaddresssigner_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    static get __struct() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.platformaddresssigner_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 all private keys as an array of {addressHash: Uint8Array, privateKey: Uint8Array}.
+     * This is used internally for cross-package access.
+     * @returns {Array<any>}
+     */
+    getPrivateKeysBytes() {
+        const ret = wasm.platformaddresssigner_getPrivateKeysBytes(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Creates a new empty PlatformAddressSigner.
+     */
+    constructor() {
+        const ret = wasm.identitysigner_new();
+        this.__wbg_ptr = ret >>> 0;
+        PlatformAddressSignerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Adds a private key and derives the Platform address from it.
+     *
+     * The address is derived as: P2PKH(Hash160(compressed_public_key))
+     *
+     * @param privateKey - The PrivateKey object
+     * @returns The derived Platform address
+     * @param {PrivateKey} private_key
+     * @returns {PlatformAddress}
+     */
+    addKey(private_key) {
+        _assertClass(private_key, PrivateKey);
+        const ret = wasm.platformaddresssigner_addKey(this.__wbg_ptr, private_key.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PlatformAddress.__wrap(ret[0]);
+    }
+    /**
+     * Returns true if this signer has a key for the given address.
+     * @param {PlatformAddressLike} address
+     * @returns {boolean}
+     */
+    hasKey(address) {
+        const ret = wasm.platformaddresssigner_hasKey(this.__wbg_ptr, address);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Returns the number of keys in this signer.
+     * @returns {number}
+     */
+    get keyCount() {
+        const ret = wasm.platformaddresssigner_key_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 const PrefundedVotingBalanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_prefundedvotingbalance_free(ptr >>> 0, 1));
@@ -13913,35 +14321,6 @@ export class TokenConfigurationChangeItem {
         const ret = wasm.tokenconfigurationchangeitem_PerpetualDistributionControlGroupItem(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) {
-        _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityAdminGroupItem(action_taker.__wbg_ptr);
-        return TokenConfigurationChangeItem.__wrap(ret);
-    }
-    /**
-     * @param {AuthorizedActionTakers} action_taker
-     * @returns {TokenConfigurationChangeItem}
-     */
-    static NewTokensDestinationIdentityControlGroupItem(action_taker) {
-        _assertClass(action_taker, AuthorizedActionTakers);
-        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityControlGroupItem(action_taker.__wbg_ptr);
-        return TokenConfigurationChangeItem.__wrap(ret);
-    }
     /**
      * @param {boolean} flag
      * @returns {TokenConfigurationChangeItem}
@@ -14005,11 +14384,39 @@ export class TokenConfigurationChangeItem {
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
-     * @param {number | null} [group_contract_position]
+     * @param {Identifier | Uint8Array | string} js_identity_id
      * @returns {TokenConfigurationChangeItem}
      */
-    static MainControlGroupItem(group_contract_position) {
-        const ret = wasm.tokenconfigurationchangeitem_MainControlGroupItem(isLikeNone(group_contract_position) ? 0xFFFFFF : group_contract_position);
+    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) {
+        _assertClass(action_taker, AuthorizedActionTakers);
+        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityAdminGroupItem(action_taker.__wbg_ptr);
+        return TokenConfigurationChangeItem.__wrap(ret);
+    }
+    /**
+     * @param {AuthorizedActionTakers} action_taker
+     * @returns {TokenConfigurationChangeItem}
+     */
+    static NewTokensDestinationIdentityControlGroupItem(action_taker) {
+        _assertClass(action_taker, AuthorizedActionTakers);
+        const ret = wasm.tokenconfigurationchangeitem_NewTokensDestinationIdentityControlGroupItem(action_taker.__wbg_ptr);
+        return TokenConfigurationChangeItem.__wrap(ret);
+    }
+    /**
+     * @returns {TokenConfigurationChangeItem}
+     */
+    static noChangeItem() {
+        const ret = wasm.tokenconfigurationchangeitem_noChangeItem();
         return TokenConfigurationChangeItem.__wrap(ret);
     }
     /**
@@ -14065,10 +14472,11 @@ export class TokenConfigurationChangeItem {
         }
     }
     /**
+     * @param {number | null} [group_contract_position]
      * @returns {TokenConfigurationChangeItem}
      */
-    static noChangeItem() {
-        const ret = wasm.tokenconfigurationchangeitem_noChangeItem();
+    static MainControlGroupItem(group_contract_position) {
+        const ret = wasm.tokenconfigurationchangeitem_MainControlGroupItem(isLikeNone(group_contract_position) ? 0xFFFFFF : group_contract_position);
         return TokenConfigurationChangeItem.__wrap(ret);
     }
 }
@@ -16886,7 +17294,7 @@ export class Vote {
     constructor(vote_poll, resource_vote_choice) {
         _assertClass(vote_poll, VotePoll);
         _assertClass(resource_vote_choice, ResourceVoteChoice);
-        const ret = wasm.vote_new(vote_poll.__wbg_ptr, resource_vote_choice.__wbg_ptr);
+        const ret = wasm.resourcevote_new(vote_poll.__wbg_ptr, resource_vote_choice.__wbg_ptr);
         this.__wbg_ptr = ret >>> 0;
         VoteFinalization.register(this, this.__wbg_ptr, this);
         return this;