dash-platform-sdk 1.3.0-dev.1 → 1.3.0-dev.10

package/src/utils/getQuorumPublicKey.js

@@ -1,69 +1,18 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+const cache = {};
+export async function getQuorumPublicKey(network, quorumType, quorumHash) {
+    const cached = cache[`${quorumType}_${quorumHash}`];
+    if (cached != null) {
+        return cached;
     }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getQuorumPublicKey = getQuorumPublicKey;
-var cache = {};
-function getQuorumPublicKey(network, quorumType, quorumHash) {
-    return __awaiter(this, void 0, void 0, function () {
-        var cached, url, resp, data, quorumPublicKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    cached = cache["".concat(quorumType, "_").concat(quorumHash)];
-                    if (cached != null) {
-                        return [2 /*return*/, cached];
-                    }
-                    url = "https://".concat(network === 'mainnet' ? '' : 'testnet.', "platform-explorer.pshenmic.dev/quorum/info?quorumType=").concat(quorumType, "&quorumHash=").concat(quorumHash);
-                    return [4 /*yield*/, fetch(url, {
-                            method: 'GET'
-                        })];
-                case 1:
-                    resp = _a.sent();
-                    if (resp.status !== 200) {
-                        throw new Error('Failed to query Platform Explorer for quorum public keys');
-                    }
-                    return [4 /*yield*/, resp.json()];
-                case 2:
-                    data = _a.sent();
-                    quorumPublicKey = data.quorumPublicKey;
-                    cache["".concat(quorumType, "_").concat(quorumHash)] = quorumPublicKey;
-                    return [2 /*return*/, quorumPublicKey];
-            }
-        });
+    const url = `https://${network === 'mainnet' ? '' : 'testnet.'}platform-explorer.pshenmic.dev/quorum/info?quorumType=${quorumType}&quorumHash=${quorumHash}`;
+    const resp = await fetch(url, {
+        method: 'GET'
     });
+    if (resp.status !== 200) {
+        throw new Error('Failed to query Platform Explorer for quorum public keys');
+    }
+    const data = await resp.json();
+    const { quorumPublicKey } = data;
+    cache[`${quorumType}_${quorumHash}`] = quorumPublicKey;
+    return quorumPublicKey;
 }

package/src/utils/getRandomArrayItem.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getRandomArrayItem;
-function getRandomArrayItem(array) {
+export default function getRandomArrayItem(array) {
     return array[Math.floor((Math.random() * array.length))];
 }

package/src/utils/getRandomBytes.d.ts

@@ -0,0 +1 @@
+export default function getRandomBytes(length: number): Uint8Array;

package/src/utils/getRandomBytes.js

@@ -0,0 +1,4 @@
+export default function getRandomBytes(length) {
+    const array = Uint8Array.from({ length });
+    return crypto.getRandomValues(array);
+}

package/src/utils/hexToBytes.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = hexToBytes;
-function hexToBytes(hex) {
-    var _a;
-    return Uint8Array.from(((_a = hex.match(/.{1,2}/g)) !== null && _a !== void 0 ? _a : []).map(function (byte) { return parseInt(byte, 16); }));
+export default function hexToBytes(hex) {
+    return Uint8Array.from((hex.match(/.{1,2}/g) ?? []).map((byte) => parseInt(byte, 16)));
 }

package/src/utils/index.d.ts

@@ -1,3 +1,4 @@
+import { IdentifierWASM } from 'pshenmic-dpp';
 /**
  * Collection of conversion functions
  *
@@ -37,13 +38,28 @@ export declare class UtilsController {
      */
     hexToBytes(hex: string): Uint8Array;
     /**
-     * Converts DPNS name to normalized format (ex. alice.dash -> al1ce.dash)
-     *
-     * source: https://github.com/dashpay/platform/blob/master/packages/js-dash-sdk/src/utils/convertToHomographSafeChars.ts
+     * @deprecated use sdk.names.normalizeLabel()
      *
      * @param str {string}
      *
      * @return {string}
      */
     convertToHomographSafeChars(str: string): string;
+    /**
+     * Creates a voting identity identifier from proTxHash and voting address
+     *
+     * @param proTxHash {string} Pro TX Hash in hex format
+     * @param publicKeyHash {string} Voting address's public key hash (20 bytes), in hex
+     *
+     * @return {Promise<string>}
+     */
+    createVoterIdentifier(proTxHash: string, publicKeyHash: string): Promise<IdentifierWASM>;
+    /**
+     * Creates a masternode identity identifier from proTxHash
+     *
+     * @param proTxHash {string} Pro TX Hash in hex format
+     *
+     * @return {string}
+     * */
+    createMasternodeIdentifier(proTxHash: string): IdentifierWASM;
 }

package/src/utils/index.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UtilsController = void 0;
-var convertToHomographSafeChars_1 = require("./convertToHomographSafeChars");
-var base_1 = require("@scure/base");
-var hexToBytes_1 = require("./hexToBytes");
-var bytesToHex_1 = require("./bytesToHex");
+import convertToHomographSafeChars from './convertToHomographSafeChars.js';
+import { base58 } from '@scure/base';
+import hexToBytes from './hexToBytes.js';
+import bytesToHex from './bytesToHex.js';
+import { createVoterIdentityId } from './createVoterIdentityId.js';
+import { createMasternodeIdentityId } from './createMasternodeIdentityId.js';
 /**
  * Collection of conversion functions
  *
  * @hideconstructor
  */
-var UtilsController = /** @class */ (function () {
-    function UtilsController() {
-    }
+export class UtilsController {
     /**
      * Converts base58 string to an Uint8Array
      *
@@ -20,9 +17,9 @@ var UtilsController = /** @class */ (function () {
      *
      * @returns {Uint8Array}
      */
-    UtilsController.prototype.base58ToBytes = function (str) {
-        return base_1.base58.decode(str);
-    };
+    base58ToBytes(str) {
+        return base58.decode(str);
+    }
     /**
      * Converts Uint8Array to base58 string
      *
@@ -30,9 +27,9 @@ var UtilsController = /** @class */ (function () {
      *
      * @return {string}
      */
-    UtilsController.prototype.bytesToBase58 = function (bytes) {
-        return base_1.base58.encode(bytes);
-    };
+    bytesToBase58(bytes) {
+        return base58.encode(bytes);
+    }
     /**
      * Converts Uint8Array to hex string
      *
@@ -40,9 +37,9 @@ var UtilsController = /** @class */ (function () {
      *
      * @return {string}
      */
-    UtilsController.prototype.bytesToHex = function (bytes) {
-        return (0, bytesToHex_1.default)(bytes);
-    };
+    bytesToHex(bytes) {
+        return bytesToHex(bytes);
+    }
     /**
      * Converts a hex string to Uint8Array
      *
@@ -50,21 +47,38 @@ var UtilsController = /** @class */ (function () {
      *
      * @return {Uint8Array}
      */
-    UtilsController.prototype.hexToBytes = function (hex) {
-        return (0, hexToBytes_1.default)(hex);
-    };
+    hexToBytes(hex) {
+        return hexToBytes(hex);
+    }
     /**
-     * Converts DPNS name to normalized format (ex. alice.dash -> al1ce.dash)
-     *
-     * source: https://github.com/dashpay/platform/blob/master/packages/js-dash-sdk/src/utils/convertToHomographSafeChars.ts
+     * @deprecated use sdk.names.normalizeLabel()
      *
      * @param str {string}
      *
      * @return {string}
      */
-    UtilsController.prototype.convertToHomographSafeChars = function (str) {
-        return (0, convertToHomographSafeChars_1.default)(str);
-    };
-    return UtilsController;
-}());
-exports.UtilsController = UtilsController;
+    convertToHomographSafeChars(str) {
+        return convertToHomographSafeChars(str);
+    }
+    /**
+     * Creates a voting identity identifier from proTxHash and voting address
+     *
+     * @param proTxHash {string} Pro TX Hash in hex format
+     * @param publicKeyHash {string} Voting address's public key hash (20 bytes), in hex
+     *
+     * @return {Promise<string>}
+     */
+    async createVoterIdentifier(proTxHash, publicKeyHash) {
+        return await createVoterIdentityId(proTxHash, publicKeyHash);
+    }
+    /**
+     * Creates a masternode identity identifier from proTxHash
+     *
+     * @param proTxHash {string} Pro TX Hash in hex format
+     *
+     * @return {string}
+     * */
+    createMasternodeIdentifier(proTxHash) {
+        return createMasternodeIdentityId(proTxHash);
+    }
+}

package/src/utils/indexBytesToString.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = indexValueBytesToString;
-function indexValueBytesToString(value) {
-    var decoder = new TextDecoder();
+export default function indexValueBytesToString(value) {
+    const decoder = new TextDecoder();
     return decoder.decode(value).slice(2);
 }

package/src/utils/sha256.d.ts

@@ -1 +1 @@
-export default function sha256(input: Uint8Array | string): Uint8Array | string;
+export default function sha256(input: Uint8Array | string): Promise<Uint8Array | string>;

package/src/utils/sha256.js

@@ -1,13 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = sha256;
-var hash_js_1 = require("hash.js");
-function sha256(input) {
-    var hash = (0, hash_js_1.sha256)().update(input);
+import bytesToHex from './bytesToHex.js';
+import { typedArrayToBuffer } from './bytesToTypedArray.js';
+export default async function sha256(input) {
     if (typeof input === 'string') {
-        return hash.digest('hex');
+        const encoder = new TextEncoder();
+        const data = encoder.encode(input);
+        const hash = await crypto.subtle.digest('SHA-256', data);
+        return bytesToHex(new Uint8Array(hash));
     }
     else {
-        return Uint8Array.from(hash.digest());
+        const arrayBuffer = typedArrayToBuffer(input);
+        const hash = await crypto.subtle.digest('SHA-256', arrayBuffer);
+        return new Uint8Array(hash);
     }
 }

package/src/utils/signHash.d.ts

@@ -1 +1 @@
-export default function signHash(quorumType: number, quorumHash: Uint8Array, requestId: Uint8Array, signBytesHash: Uint8Array): Uint8Array;
+export default function signHash(quorumType: number, quorumHash: Uint8Array, requestId: Uint8Array, signBytesHash: Uint8Array): Promise<Uint8Array>;

package/src/utils/signHash.js

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = signHash;
-var sha256_1 = require("./sha256");
-function signHash(quorumType, quorumHash, requestId, signBytesHash) {
+import sha256 from './sha256.js';
+export default async function signHash(quorumType, quorumHash, requestId, signBytesHash) {
     // Calculate total length: 1 byte for quorumType + 3 arrays of 32 bytes each
-    var totalLength = 1 + quorumHash.length + requestId.length + signBytesHash.length;
-    var combined = new Uint8Array(totalLength);
-    var offset = 0;
+    const totalLength = 1 + quorumHash.length + requestId.length + signBytesHash.length;
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
     // Add quorumType as single byte
     combined[offset] = quorumType;
     offset += 1;
     // Add reversed quorumHash
-    var reversedQuorumHash = new Uint8Array(quorumHash).reverse();
+    const reversedQuorumHash = new Uint8Array(quorumHash).reverse();
     combined.set(reversedQuorumHash, offset);
     offset += quorumHash.length;
     // Add reversed requestId
-    var reversedRequestId = new Uint8Array(requestId).reverse();
+    const reversedRequestId = new Uint8Array(requestId).reverse();
     combined.set(reversedRequestId, offset);
     offset += requestId.length;
     // Add reversed signBytesHash
-    var reversedSignBytesHash = new Uint8Array(signBytesHash).reverse();
+    const reversedSignBytesHash = new Uint8Array(signBytesHash).reverse();
     combined.set(reversedSignBytesHash, offset);
-    return (0, sha256_1.default)((0, sha256_1.default)(combined));
+    return await sha256(await sha256(combined));
 }

package/src/utils/signRequestId.d.ts

@@ -1 +1 @@
-export default function signRequestId(prefix: string, height: bigint, round: number): Uint8Array;
+export default function signRequestId(prefix: string, height: bigint, round: number): Promise<Uint8Array>;

package/src/utils/signRequestId.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = signRequestId;
-var sha256_1 = require("./sha256");
-function signRequestId(prefix, height, round) {
-    var prefixBytes = new TextEncoder().encode(prefix);
+import sha256 from './sha256.js';
+export default async function signRequestId(prefix, height, round) {
+    const prefixBytes = new TextEncoder().encode(prefix);
     // len + i64 + i32 (prefix length + 8 bytes for height + 4 bytes for round)
-    var totalLength = prefixBytes.length + 8 + 4;
-    var buffer = new ArrayBuffer(totalLength);
-    var view = new DataView(buffer);
-    var uint8View = new Uint8Array(buffer);
-    var offset = 0;
+    const totalLength = prefixBytes.length + 8 + 4;
+    const buffer = new ArrayBuffer(totalLength);
+    const view = new DataView(buffer);
+    const uint8View = new Uint8Array(buffer);
+    let offset = 0;
     // Copy prefix bytes
     uint8View.set(prefixBytes, offset);
     offset += prefixBytes.length;
@@ -18,5 +15,5 @@ function signRequestId(prefix, height, round) {
     offset += 8;
     // Write round as 32-bit little-endian integer
     view.setInt32(offset, round, true);
-    return (0, sha256_1.default)(uint8View);
+    return await sha256(uint8View);
 }

package/src/utils/sleep.d.ts

@@ -0,0 +1 @@
+export default function sleep(ms: number): Promise<void>;

package/src/utils/sleep.js

@@ -0,0 +1,3 @@
+export default async function sleep(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/utils/stringToIndexValueBytes.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = stringToIndexValueBytes;
-function stringToIndexValueBytes(name) {
-    var lengthBuffer = new Uint8Array(1);
+export default function stringToIndexValueBytes(name) {
+    const lengthBuffer = new Uint8Array(1);
     lengthBuffer[0] = name.length;
-    var nameBuffer = new TextEncoder().encode(name);
-    var result = new Uint8Array(1 + 1 + nameBuffer.length);
+    const nameBuffer = new TextEncoder().encode(name);
+    const result = new Uint8Array(1 + 1 + nameBuffer.length);
     result[0] = 0x12;
     result[1] = lengthBuffer[0];
     result.set(nameBuffer, 2);

package/src/utils/verifyTenderdashProof.d.ts

@@ -1,2 +1,2 @@
-import { Proof, ResponseMetadata } from '../../proto/generated/platform';
-export default function verifyTenderdashProof(proof: Proof, metadata: ResponseMetadata, rootHash: Uint8Array, quorumPublicKey: string): boolean;
+import { Proof, ResponseMetadata } from '../../proto/generated/platform.js';
+export default function verifyTenderdashProof(proof: Proof, metadata: ResponseMetadata, rootHash: Uint8Array, quorumPublicKey: string): Promise<boolean>;

package/src/utils/verifyTenderdashProof.js

@@ -1,30 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = verifyTenderdashProof;
-var platform_1 = require("../../proto/generated/platform");
-var calculateSignHash_1 = require("./calculateSignHash");
-var calculateStateIdHash_1 = require("./calculateStateIdHash");
-// import verifyBls from './verifyBls'
-var pshenmic_dpp_1 = require("pshenmic-dpp");
-var hexToBytes_1 = require("./hexToBytes");
-function verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey) {
-    var stateId = platform_1.StateId.fromPartial({
+import { CanonicalVote, SignedMsgType, StateId } from '../../proto/generated/platform.js';
+import { calculateSignHash } from './calculateSignHash.js';
+import { calculateStateIdHash } from './calculateStateIdHash.js';
+import { verifySignatureDigest } from 'pshenmic-dpp';
+import hexToBytes from './hexToBytes.js';
+export default async function verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey) {
+    const stateId = StateId.create({
         appVersion: String(metadata.protocolVersion),
         coreChainLockedHeight: metadata.coreChainLockedHeight,
         time: metadata.timeMs,
         appHash: rootHash,
         height: metadata.height
     });
-    var stateIdHash = (0, calculateStateIdHash_1.calculateStateIdHash)(stateId);
-    var commit = platform_1.CanonicalVote.fromPartial({
-        type: platform_1.SignedMsgType.PRECOMMIT,
+    const stateIdHash = await calculateStateIdHash(stateId);
+    const commit = CanonicalVote.create({
+        type: SignedMsgType.PRECOMMIT,
         blockId: proof.blockIdHash,
         chainId: metadata.chainId,
         height: metadata.height,
         round: String(proof.round),
         stateId: stateIdHash
     });
-    var signDigest = (0, calculateSignHash_1.calculateSignHash)(commit, metadata.chainId, proof.quorumType, proof.quorumHash, BigInt(metadata.height), proof.round);
-    var signature = proof.signature;
-    return (0, pshenmic_dpp_1.verifySignatureDigest)(Uint8Array.from(signDigest), signature, (0, hexToBytes_1.default)(quorumPublicKey));
+    const signDigest = await calculateSignHash(commit, metadata.chainId, proof.quorumType, proof.quorumHash, BigInt(metadata.height), proof.round);
+    const { signature } = proof;
+    return verifySignatureDigest(Uint8Array.from(signDigest), signature, hexToBytes(quorumPublicKey));
 }

package/src/voting/createStateTransition.d.ts

@@ -0,0 +1,2 @@
+import { StateTransitionWASM, VoteWASM } from 'pshenmic-dpp';
+export default function createStateTransition(voteWASM: VoteWASM, proTxHash: string, identityNonce: bigint): StateTransitionWASM;

package/src/voting/createStateTransition.js

@@ -0,0 +1,6 @@
+import { IdentifierWASM, MasternodeVoteTransitionWASM } from 'pshenmic-dpp';
+export default function createStateTransition(voteWASM, proTxHash, identityNonce) {
+    const voterIdentity = IdentifierWASM.fromHex(proTxHash);
+    const masternodeVoteTransition = new MasternodeVoteTransitionWASM(proTxHash, voterIdentity, voteWASM, identityNonce);
+    return masternodeVoteTransition.toStateTransition();
+}

package/src/voting/createVote.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierWASM, ResourceVoteChoiceWASM, VoteWASM } from 'pshenmic-dpp';
+export default function createVote(dataContractId: IdentifierWASM, documentTypeName: string, indexName: string, indexValues: string[], choice: ResourceVoteChoiceWASM): VoteWASM;

package/src/voting/createVote.js

@@ -0,0 +1,5 @@
+import { VotePollWASM, VoteWASM } from 'pshenmic-dpp';
+export default function createVote(dataContractId, documentTypeName, indexName, indexValues, choice) {
+    const votePoll = new VotePollWASM(dataContractId, documentTypeName, indexName, indexValues);
+    return new VoteWASM(votePoll, choice);
+}

package/src/voting/index.d.ts

@@ -0,0 +1,37 @@
+import { IdentifierLike, ResourceVoteChoice } from '../types.js';
+import { IdentifierWASM, StateTransitionWASM, VoteWASM } from 'pshenmic-dpp';
+/**
+ * Voting controller for performing masternode votes
+ *
+ * @hideconstructor
+ */
+export declare class VotingController {
+    /**
+     * Creates an {IdentifierWASM} from masternode pro tx hash and voting address (public key hash)
+     *
+     * @param proTxHash {string} voter's masternode pro tx hash
+     * @param publicKeyHash {string} voter address's public key hash
+     *
+     * @return {Promise<IdentifierWASM>}
+     */
+    createVoterIdentityId(proTxHash: string, publicKeyHash: string): Promise<IdentifierWASM>;
+    /**
+       * Creates a {VoteWASM} with all information about the vote, such as data contract id, choice, and target index
+       *
+       * @param dataContractId {DataContractWASM}
+       * @param documentTypeName {string}
+       * @param indexName {string}
+       * @param indexValues {string[]}
+       * @param choice {ResourceVoteChoice}
+       */
+    createVote(dataContractId: IdentifierLike, documentTypeName: string, indexName: string, indexValues: string[], choice: ResourceVoteChoice): VoteWASM;
+    /**
+       * Creates a {StateTransitionWASM} from masternode Pro Tx Hash and voter identity
+       *
+       * @param voteWASM {VoteWASM} vote instance from .createMasternodeVote() method
+       * @param proTxHash {string} pro tx hash of the masternode as hex
+       * @param voterIdentity {IdentifierWASM} voter identity identifier
+       * @param identityNonce {BigInt} identity nonce
+       */
+    createStateTransition(voteWASM: VoteWASM, proTxHash: string, voterIdentity: IdentifierWASM, identityNonce: bigint): StateTransitionWASM;
+}

package/src/voting/index.js

@@ -0,0 +1,55 @@
+import createVote from './createVote.js';
+import { IdentifierWASM, MasternodeVoteTransitionWASM, ResourceVoteChoiceWASM } from 'pshenmic-dpp';
+import { createVoterIdentityId } from '../utils/createVoterIdentityId.js';
+/**
+ * Voting controller for performing masternode votes
+ *
+ * @hideconstructor
+ */
+export class VotingController {
+    /**
+     * Creates an {IdentifierWASM} from masternode pro tx hash and voting address (public key hash)
+     *
+     * @param proTxHash {string} voter's masternode pro tx hash
+     * @param publicKeyHash {string} voter address's public key hash
+     *
+     * @return {Promise<IdentifierWASM>}
+     */
+    async createVoterIdentityId(proTxHash, publicKeyHash) {
+        return await createVoterIdentityId(proTxHash, publicKeyHash);
+    }
+    /**
+       * Creates a {VoteWASM} with all information about the vote, such as data contract id, choice, and target index
+       *
+       * @param dataContractId {DataContractWASM}
+       * @param documentTypeName {string}
+       * @param indexName {string}
+       * @param indexValues {string[]}
+       * @param choice {ResourceVoteChoice}
+       */
+    createVote(dataContractId, documentTypeName, indexName, indexValues, choice) {
+        let resourceVoteChoice;
+        if (choice === 'lock') {
+            resourceVoteChoice = ResourceVoteChoiceWASM.Lock();
+        }
+        else if (choice === 'abstain') {
+            resourceVoteChoice = ResourceVoteChoiceWASM.Abstain();
+        }
+        else {
+            resourceVoteChoice = ResourceVoteChoiceWASM.TowardsIdentity(new IdentifierWASM(choice));
+        }
+        return createVote(new IdentifierWASM(dataContractId), documentTypeName, indexName, indexValues, resourceVoteChoice);
+    }
+    /**
+       * Creates a {StateTransitionWASM} from masternode Pro Tx Hash and voter identity
+       *
+       * @param voteWASM {VoteWASM} vote instance from .createMasternodeVote() method
+       * @param proTxHash {string} pro tx hash of the masternode as hex
+       * @param voterIdentity {IdentifierWASM} voter identity identifier
+       * @param identityNonce {BigInt} identity nonce
+       */
+    createStateTransition(voteWASM, proTxHash, voterIdentity, identityNonce) {
+        const transition = new MasternodeVoteTransitionWASM(IdentifierWASM.fromHex(proTxHash), new IdentifierWASM(voterIdentity), voteWASM, identityNonce);
+        return transition.toStateTransition();
+    }
+}