pshenmic-dpp 1.1.2-dev.8 → 2.0.0-dev.10

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditWithdrawalTransition.d.ts

@@ -0,0 +1,42 @@
+import type { IdentityCreditWithdrawalTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike, PoolingLike } from '../../types.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityCreditWithdrawalTransitionWASM {
+    /** @private **/
+    _rawIdentityCreditWithdrawalTransition: IdentityCreditWithdrawalTransitionNAPI;
+    constructor(identityId: IdentifierLike, amount: bigint, coreFeePerByte: number, pooling: PoolingLike, nonce: bigint, outputScript?: CoreScriptWASM, userFeeIncrease?: number);
+    get outputScript(): CoreScriptWASM | undefined;
+    set outputScript(script: CoreScriptWASM | undefined);
+    get pooling(): string;
+    set pooling(value: PoolingLike);
+    get identityId(): IdentifierWASM;
+    set identityId(value: IdentifierLike);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    get nonce(): bigint;
+    set nonce(value: bigint);
+    get amount(): bigint;
+    set amount(value: bigint);
+    get coreFeePerByte(): number;
+    set coreFeePerByte(value: number);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    get signaturePublicKeyId(): number;
+    set signaturePublicKeyId(value: number);
+    getSignableBytes(): Uint8Array;
+    getPurposeRequirement(): string[];
+    getModifiedDataIds(): IdentifierWASM[];
+    getOptionalAssetLockProof(): AssetLockProofWASM | undefined;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): IdentityCreditWithdrawalTransitionWASM;
+    static fromHex(hex: string): IdentityCreditWithdrawalTransitionWASM;
+    static fromBase64(base64: string): IdentityCreditWithdrawalTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): IdentityCreditWithdrawalTransitionWASM;
+    static createFromRawInstance(rawInstance: IdentityCreditWithdrawalTransitionNAPI): IdentityCreditWithdrawalTransitionWASM;
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditWithdrawalTransition.js

@@ -0,0 +1,114 @@
+import { dppProvider } from '../../provider.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityCreditWithdrawalTransitionWASM {
+    /** @private **/
+    _rawIdentityCreditWithdrawalTransition;
+    constructor(identityId, amount, coreFeePerByte, pooling, nonce, outputScript, userFeeIncrease) {
+        this._rawIdentityCreditWithdrawalTransition = new dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI(prepareIdentifierValue(identityId), amount.toString(), coreFeePerByte, valueToDynamicValue(pooling), nonce.toString(), outputScript?._rawCoreScript, userFeeIncrease);
+    }
+    get outputScript() {
+        const script = this._rawIdentityCreditWithdrawalTransition.outputScript;
+        if (script != null) {
+            return CoreScriptWASM.createFromRawInstance(script);
+        }
+    }
+    set outputScript(script) {
+        this._rawIdentityCreditWithdrawalTransition.outputScript = script?._rawCoreScript;
+    }
+    get pooling() {
+        return this._rawIdentityCreditWithdrawalTransition.pooling;
+    }
+    set pooling(value) {
+        this._rawIdentityCreditWithdrawalTransition.pooling = valueToDynamicValue(value);
+    }
+    get identityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityCreditWithdrawalTransition.identityId);
+    }
+    set identityId(value) {
+        this._rawIdentityCreditWithdrawalTransition.identityId = prepareIdentifierValue(value);
+    }
+    get userFeeIncrease() {
+        return this._rawIdentityCreditWithdrawalTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawIdentityCreditWithdrawalTransition.userFeeIncrease = value;
+    }
+    get nonce() {
+        return BigInt(this._rawIdentityCreditWithdrawalTransition.nonce);
+    }
+    set nonce(value) {
+        this._rawIdentityCreditWithdrawalTransition.nonce = value.toString();
+    }
+    get amount() {
+        return BigInt(this._rawIdentityCreditWithdrawalTransition.amount);
+    }
+    set amount(value) {
+        this._rawIdentityCreditWithdrawalTransition.amount = value.toString();
+    }
+    get coreFeePerByte() {
+        return this._rawIdentityCreditWithdrawalTransition.coreFeePerByte;
+    }
+    set coreFeePerByte(value) {
+        this._rawIdentityCreditWithdrawalTransition.coreFeePerByte = value;
+    }
+    get signature() {
+        return this._rawIdentityCreditWithdrawalTransition.signature;
+    }
+    set signature(value) {
+        this._rawIdentityCreditWithdrawalTransition.signature = value;
+    }
+    get signaturePublicKeyId() {
+        return this._rawIdentityCreditWithdrawalTransition.signaturePublicKeyId;
+    }
+    set signaturePublicKeyId(value) {
+        this._rawIdentityCreditWithdrawalTransition.signaturePublicKeyId = value;
+    }
+    getSignableBytes() {
+        return this._rawIdentityCreditWithdrawalTransition.getSignableBytes();
+    }
+    getPurposeRequirement() {
+        return this._rawIdentityCreditWithdrawalTransition.getPurposeRequirement();
+    }
+    getModifiedDataIds() {
+        return this._rawIdentityCreditWithdrawalTransition.getModifiedDataIds().map(IdentifierWASM.createFromRawInstance);
+    }
+    getOptionalAssetLockProof() {
+        const lock = this._rawIdentityCreditWithdrawalTransition.getOptionalAssetLockProof();
+        if (lock != null) {
+            return AssetLockProofWASM.createFromRawInstance(lock);
+        }
+    }
+    bytes() {
+        return this._rawIdentityCreditWithdrawalTransition.bytes();
+    }
+    hex() {
+        return this._rawIdentityCreditWithdrawalTransition.hex();
+    }
+    base64() {
+        return this._rawIdentityCreditWithdrawalTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityCreditWithdrawalTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return IdentityCreditWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return IdentityCreditWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return IdentityCreditWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return IdentityCreditWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityCreditWithdrawalTransitionWASM.prototype);
+        instance._rawIdentityCreditWithdrawalTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityTopUpTransition.d.ts

@@ -0,0 +1,30 @@
+import type { IdentityTopUpTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityTopUpTransitionWASM {
+    /** @private **/
+    _rawIdentityTopUpTransition: IdentityTopUpTransitionNAPI;
+    constructor(assetLockProof: AssetLockProofWASM, identityId: IdentifierLike, userFeeIncrease?: number);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    get identityIdentifier(): IdentifierWASM;
+    set identityIdentifier(id: IdentifierLike);
+    get assetLockProof(): AssetLockProofWASM;
+    set assetLockProof(value: AssetLockProofWASM);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    getSignableBytes(): Uint8Array;
+    getModifiedDataIds(): IdentifierWASM[];
+    getOptionalAssetLockProof(): AssetLockProofWASM | undefined;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): IdentityTopUpTransitionWASM;
+    static fromHex(hex: string): IdentityTopUpTransitionWASM;
+    static fromBase64(base64: string): IdentityTopUpTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): IdentityTopUpTransitionWASM;
+    static createFromRawInstance(rawInstance: IdentityTopUpTransitionNAPI): IdentityTopUpTransitionWASM;
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityTopUpTransition.js

@@ -0,0 +1,75 @@
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityTopUpTransitionWASM {
+    /** @private **/
+    _rawIdentityTopUpTransition;
+    constructor(assetLockProof, identityId, userFeeIncrease) {
+        this._rawIdentityTopUpTransition = new dppProvider.dpp.IdentityTopUpTransitionNAPI(assetLockProof._rawAssetLockProof, prepareIdentifierValue(identityId), userFeeIncrease);
+    }
+    get userFeeIncrease() {
+        return this._rawIdentityTopUpTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawIdentityTopUpTransition.userFeeIncrease = value;
+    }
+    get identityIdentifier() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityTopUpTransition.identityIdentifier);
+    }
+    set identityIdentifier(id) {
+        this._rawIdentityTopUpTransition.identityIdentifier = prepareIdentifierValue(id);
+    }
+    get assetLockProof() {
+        return AssetLockProofWASM.createFromRawInstance(this._rawIdentityTopUpTransition.assetLockProof);
+    }
+    set assetLockProof(value) {
+        this._rawIdentityTopUpTransition.assetLockProof = value._rawAssetLockProof;
+    }
+    get signature() {
+        return this._rawIdentityTopUpTransition.signature;
+    }
+    set signature(value) {
+        this._rawIdentityTopUpTransition.signature = value;
+    }
+    getSignableBytes() {
+        return this._rawIdentityTopUpTransition.getSignableBytes();
+    }
+    getModifiedDataIds() {
+        return this._rawIdentityTopUpTransition.getModifiedDataIds().map(IdentifierWASM.createFromRawInstance);
+    }
+    getOptionalAssetLockProof() {
+        const lock = this._rawIdentityTopUpTransition.getOptionalAssetLockProof();
+        return (lock != null) ? AssetLockProofWASM.createFromRawInstance(lock) : undefined;
+    }
+    bytes() {
+        return this._rawIdentityTopUpTransition.bytes();
+    }
+    hex() {
+        return this._rawIdentityTopUpTransition.hex();
+    }
+    base64() {
+        return this._rawIdentityTopUpTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityTopUpTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return IdentityTopUpTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return IdentityTopUpTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return IdentityTopUpTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return IdentityTopUpTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityTopUpTransitionWASM.prototype);
+        instance._rawIdentityTopUpTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityUpdateTransition.d.ts

@@ -0,0 +1,40 @@
+import type { IdentityUpdateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityUpdateTransitionWASM {
+    /** @private **/
+    _rawIdentityUpdateTransition: IdentityUpdateTransitionNAPI;
+    constructor(identityId: IdentifierLike, revision: bigint, nonce: bigint, addPublicKeys: IdentityPublicKeyInCreationWASM[], disablePublicKeys: number[], userFeeIncrease?: number);
+    get revision(): bigint;
+    set revision(value: bigint);
+    get nonce(): bigint;
+    set nonce(value: bigint);
+    get identityIdentifier(): IdentifierWASM;
+    set identityIdentifier(value: IdentifierLike);
+    get publicKeyIdsToDisable(): number[];
+    set publicKeyIdsToDisable(value: number[]);
+    get publicKeyIdsToAdd(): IdentityPublicKeyInCreationWASM[];
+    set publicKeyIdsToAdd(value: IdentityPublicKeyInCreationWASM[]);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    get signaturePublicKeyId(): number;
+    set signaturePublicKeyId(value: number);
+    getSignableBytes(): Uint8Array;
+    getPurposeRequirement(): string[];
+    getModifiedDataIds(): IdentifierWASM[];
+    getOptionalAssetLockProof(): AssetLockProofWASM | undefined;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): IdentityUpdateTransitionWASM;
+    static fromHex(hex: string): IdentityUpdateTransitionWASM;
+    static fromBase64(base64: string): IdentityUpdateTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): IdentityUpdateTransitionWASM;
+    static createFromRawInstance(rawInstance: IdentityUpdateTransitionNAPI): IdentityUpdateTransitionWASM;
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityUpdateTransition.js

@@ -0,0 +1,108 @@
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityUpdateTransitionWASM {
+    /** @private **/
+    _rawIdentityUpdateTransition;
+    constructor(identityId, revision, nonce, addPublicKeys, disablePublicKeys, userFeeIncrease) {
+        this._rawIdentityUpdateTransition = new dppProvider.dpp.IdentityUpdateTransitionNAPI(prepareIdentifierValue(identityId), revision.toString(), nonce.toString(), addPublicKeys.map(key => key._rawKeyInCreation), disablePublicKeys, userFeeIncrease);
+    }
+    get revision() {
+        return BigInt(this._rawIdentityUpdateTransition.revision);
+    }
+    set revision(value) {
+        this._rawIdentityUpdateTransition.revision = value.toString();
+    }
+    get nonce() {
+        return BigInt(this._rawIdentityUpdateTransition.nonce);
+    }
+    set nonce(value) {
+        this._rawIdentityUpdateTransition.nonce = value.toString();
+    }
+    get identityIdentifier() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityUpdateTransition.identityIdentifier);
+    }
+    set identityIdentifier(value) {
+        this._rawIdentityUpdateTransition.identityIdentifier = prepareIdentifierValue(value);
+    }
+    get publicKeyIdsToDisable() {
+        return this._rawIdentityUpdateTransition.publicKeyIdsToDisable;
+    }
+    set publicKeyIdsToDisable(value) {
+        this._rawIdentityUpdateTransition.publicKeyIdsToDisable = value;
+    }
+    get publicKeyIdsToAdd() {
+        return this._rawIdentityUpdateTransition.publicKeyIdsToAdd.map(IdentityPublicKeyInCreationWASM.createFromRawInstance);
+    }
+    set publicKeyIdsToAdd(value) {
+        this._rawIdentityUpdateTransition.publicKeyIdsToAdd = value.map(key => key._rawKeyInCreation);
+    }
+    get userFeeIncrease() {
+        return this._rawIdentityUpdateTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawIdentityUpdateTransition.userFeeIncrease = value;
+    }
+    get signature() {
+        return this._rawIdentityUpdateTransition.signature;
+    }
+    set signature(value) {
+        this._rawIdentityUpdateTransition.signature = value;
+    }
+    get signaturePublicKeyId() {
+        return this._rawIdentityUpdateTransition.signaturePublicKeyId;
+    }
+    set signaturePublicKeyId(value) {
+        this._rawIdentityUpdateTransition.signaturePublicKeyId = value;
+    }
+    getSignableBytes() {
+        return this._rawIdentityUpdateTransition.getSignableBytes();
+    }
+    getPurposeRequirement() {
+        return this._rawIdentityUpdateTransition.getPurposeRequirement();
+    }
+    getModifiedDataIds() {
+        return this._rawIdentityUpdateTransition.getModifiedDataIds().map(IdentifierWASM.createFromRawInstance);
+    }
+    getOptionalAssetLockProof() {
+        const lock = this._rawIdentityUpdateTransition.getOptionalAssetLockProof();
+        if (lock != null) {
+            return AssetLockProofWASM.createFromRawInstance(lock);
+        }
+        else {
+            return undefined;
+        }
+    }
+    bytes() {
+        return this._rawIdentityUpdateTransition.bytes();
+    }
+    hex() {
+        return this._rawIdentityUpdateTransition.hex();
+    }
+    base64() {
+        return this._rawIdentityUpdateTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityUpdateTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return IdentityUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityUpdateTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return IdentityUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityUpdateTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return IdentityUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityUpdateTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return IdentityUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityUpdateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityUpdateTransitionWASM.prototype);
+        instance._rawIdentityUpdateTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/InstantLock.d.ts

@@ -0,0 +1,17 @@
+import type { InstantLockNAPI } from '../../../binaries/bindingsTypes.js';
+import { OutPointWASM } from './AssetLockProof/OutPoint.js';
+export declare class InstantLockWASM {
+    _rawInstantLock: InstantLockNAPI;
+    constructor(version: number, inputs: OutPointWASM[], txId: string, cycleHash: string, blsSignature: string);
+    get version(): number;
+    set version(version: number);
+    get inputs(): OutPointWASM[];
+    set inputs(inputs: OutPointWASM[]);
+    get txid(): string;
+    set txid(txid: string);
+    get cyclehash(): string;
+    set cyclehash(hash: string);
+    get blsSignature(): string;
+    set blsSignature(sig: string);
+    static createFromRawInstance(rawInstance: InstantLockNAPI): InstantLockWASM;
+}

package/dist/src/dpp/structs/InstantLock.js

@@ -0,0 +1,43 @@
+import { OutPointWASM } from './AssetLockProof/OutPoint.js';
+import { dppProvider } from '../provider.js';
+export class InstantLockWASM {
+    _rawInstantLock;
+    constructor(version, inputs, txId, cycleHash, blsSignature) {
+        this._rawInstantLock = new dppProvider.dpp.InstantLockNAPI(version, inputs.map(input => input._rawOutPoint), txId, cycleHash, blsSignature);
+    }
+    get version() {
+        return this._rawInstantLock.version;
+    }
+    set version(version) {
+        this._rawInstantLock.version = version;
+    }
+    get inputs() {
+        return this.inputs.map(OutPointWASM.createFromRawInstance);
+    }
+    set inputs(inputs) {
+        this._rawInstantLock.inputs = inputs.map(input => input._rawOutPoint);
+    }
+    get txid() {
+        return this._rawInstantLock.txid;
+    }
+    set txid(txid) {
+        this._rawInstantLock.txid = txid;
+    }
+    get cyclehash() {
+        return this._rawInstantLock.cyclehash;
+    }
+    set cyclehash(hash) {
+        this._rawInstantLock.cyclehash = hash;
+    }
+    get blsSignature() {
+        return this._rawInstantLock.blsSignature;
+    }
+    set blsSignature(sig) {
+        this._rawInstantLock.blsSignature = sig;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(InstantLockWASM.prototype);
+        instance._rawInstantLock = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/MasternodeVote/MasternodeVoteTransition.d.ts

@@ -0,0 +1,37 @@
+import type { MasternodeVoteTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { VoteWASM } from './Vote.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class MasternodeVoteTransitionWASM {
+    /** @private **/
+    _rawMasternodeVoteTransition: MasternodeVoteTransitionNAPI;
+    constructor(proTxHash: IdentifierLike, voterId: IdentifierLike, vote: VoteWASM, nonce: bigint, signaturePublicKey?: number, signature?: Uint8Array);
+    get proTxHash(): IdentifierWASM;
+    set proTxHash(id: IdentifierLike);
+    get voterIdentityId(): IdentifierWASM;
+    set voterIdentityId(id: IdentifierLike);
+    get vote(): VoteWASM;
+    set vote(vote: VoteWASM);
+    get nonce(): bigint;
+    set nonce(nonce: bigint);
+    get signaturePublicKeyId(): number;
+    set signaturePublicKeyId(keyId: number);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    get assetLock(): AssetLockProofWASM | undefined;
+    get modifiedDataIds(): IdentifierWASM[];
+    getSignableBytes(): Uint8Array;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): MasternodeVoteTransitionWASM;
+    static fromHex(hex: string): MasternodeVoteTransitionWASM;
+    static fromBase64(base64: string): MasternodeVoteTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): MasternodeVoteTransitionWASM;
+    static createFromRawInstance(rawInstance: MasternodeVoteTransitionNAPI): MasternodeVoteTransitionWASM;
+}

package/dist/src/dpp/structs/MasternodeVote/MasternodeVoteTransition.js

@@ -0,0 +1,96 @@
+import { VoteWASM } from './Vote.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class MasternodeVoteTransitionWASM {
+    /** @private **/
+    _rawMasternodeVoteTransition;
+    constructor(proTxHash, voterId, vote, nonce, signaturePublicKey, signature) {
+        this._rawMasternodeVoteTransition = new dppProvider.dpp.MasternodeVoteTransitionNAPI(prepareIdentifierValue(proTxHash), prepareIdentifierValue(voterId), vote._rawVote, nonce.toString(), signaturePublicKey, signature);
+    }
+    get proTxHash() {
+        return IdentifierWASM.createFromRawInstance(this._rawMasternodeVoteTransition.proTxHash);
+    }
+    set proTxHash(id) {
+        this._rawMasternodeVoteTransition.proTxHash = prepareIdentifierValue(id);
+    }
+    get voterIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawMasternodeVoteTransition.voterIdentityId);
+    }
+    set voterIdentityId(id) {
+        this._rawMasternodeVoteTransition.voterIdentityId = prepareIdentifierValue(id);
+    }
+    get vote() {
+        return VoteWASM.createFromRawInstance(this._rawMasternodeVoteTransition.vote);
+    }
+    set vote(vote) {
+        this._rawMasternodeVoteTransition.vote = vote._rawVote;
+    }
+    get nonce() {
+        return BigInt(this._rawMasternodeVoteTransition.nonce);
+    }
+    set nonce(nonce) {
+        this._rawMasternodeVoteTransition.nonce = nonce.toString();
+    }
+    get signaturePublicKeyId() {
+        return this._rawMasternodeVoteTransition.signaturePublicKeyId;
+    }
+    set signaturePublicKeyId(keyId) {
+        this._rawMasternodeVoteTransition.signaturePublicKeyId = keyId;
+    }
+    get signature() {
+        return this._rawMasternodeVoteTransition.signature;
+    }
+    set signature(value) {
+        this._rawMasternodeVoteTransition.signature = value;
+    }
+    get userFeeIncrease() {
+        return this._rawMasternodeVoteTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawMasternodeVoteTransition.userFeeIncrease = value;
+    }
+    get assetLock() {
+        const lock = this._rawMasternodeVoteTransition.assetLock;
+        if (lock != null) {
+            return AssetLockProofWASM.createFromRawInstance(lock);
+        }
+    }
+    get modifiedDataIds() {
+        return this._rawMasternodeVoteTransition.modifiedDataIds.map(IdentifierWASM.createFromRawInstance);
+    }
+    getSignableBytes() {
+        return this._rawMasternodeVoteTransition.getSignableBytes();
+    }
+    bytes() {
+        return this._rawMasternodeVoteTransition.bytes();
+    }
+    hex() {
+        return this._rawMasternodeVoteTransition.hex();
+    }
+    base64() {
+        return this._rawMasternodeVoteTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawMasternodeVoteTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return MasternodeVoteTransitionWASM.createFromRawInstance(dppProvider.dpp.MasternodeVoteTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return MasternodeVoteTransitionWASM.createFromRawInstance(dppProvider.dpp.MasternodeVoteTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return MasternodeVoteTransitionWASM.createFromRawInstance(dppProvider.dpp.MasternodeVoteTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return MasternodeVoteTransitionWASM.createFromRawInstance(dppProvider.dpp.MasternodeVoteTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(MasternodeVoteTransitionWASM.prototype);
+        instance._rawMasternodeVoteTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/MasternodeVote/ResourceVoteChoice.d.ts

@@ -0,0 +1,14 @@
+import type { ResourceVoteChoiceNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class ResourceVoteChoiceWASM {
+    /** @private **/
+    _rawResourceVoteChoice: ResourceVoteChoiceNAPI;
+    private constructor();
+    getValue(): IdentifierWASM | undefined;
+    getType(): string;
+    static TowardsIdentity(id: IdentifierLike): ResourceVoteChoiceWASM;
+    static Abstain(): ResourceVoteChoiceWASM;
+    static Lock(): ResourceVoteChoiceWASM;
+    static createFromRawInstance(rawInstance: ResourceVoteChoiceNAPI): ResourceVoteChoiceWASM;
+}

package/dist/src/dpp/structs/MasternodeVote/ResourceVoteChoice.js

@@ -0,0 +1,29 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class ResourceVoteChoiceWASM {
+    /** @private **/
+    _rawResourceVoteChoice;
+    constructor(rawResourceVoteChoice) {
+        this._rawResourceVoteChoice = rawResourceVoteChoice;
+    }
+    getValue() {
+        const val = this._rawResourceVoteChoice.getValue();
+        return val != null ? IdentifierWASM.createFromRawInstance(val) : undefined;
+    }
+    getType() {
+        return this._rawResourceVoteChoice.getType();
+    }
+    static TowardsIdentity(id) {
+        return ResourceVoteChoiceWASM.createFromRawInstance(dppProvider.dpp.ResourceVoteChoiceNAPI.TowardsIdentity(prepareIdentifierValue(id)));
+    }
+    static Abstain() {
+        return ResourceVoteChoiceWASM.createFromRawInstance(dppProvider.dpp.ResourceVoteChoiceNAPI.Abstain());
+    }
+    static Lock() {
+        return ResourceVoteChoiceWASM.createFromRawInstance(dppProvider.dpp.ResourceVoteChoiceNAPI.Lock());
+    }
+    static createFromRawInstance(rawInstance) {
+        return new ResourceVoteChoiceWASM(rawInstance);
+    }
+}

package/dist/src/dpp/structs/MasternodeVote/Vote.d.ts

@@ -0,0 +1,13 @@
+import type { VoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { VotePollWASM } from './VotePoll.js';
+import { ResourceVoteChoiceWASM } from './ResourceVoteChoice.js';
+export declare class VoteWASM {
+    /** @private **/
+    _rawVote: VoteNAPI;
+    constructor(votePoll: VotePollWASM, resourceVoteChoice: ResourceVoteChoiceWASM);
+    get votePoll(): VotePollWASM;
+    set votePoll(votePoll: VotePollWASM);
+    get resourceVoteChoice(): ResourceVoteChoiceWASM;
+    set resourceVoteChoice(resourceVoteChoice: ResourceVoteChoiceWASM);
+    static createFromRawInstance(rawInstance: VoteNAPI): VoteWASM;
+}