dash-platform-sdk 1.3.0-dev.5 → 1.3.0-dev.6

package/src/tokens/getIdentityTokensBalances.js

@@ -0,0 +1,43 @@
+import { IdentifierWASM, PlatformVersionWASM, verifyTokensBalancesForIdentityProof } from 'pshenmic-dpp';
+import { GetIdentityTokenBalancesRequest } from '../../proto/generated/platform';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getIdentityTokensBalances(grpcPool, identifier, tokenIdentifiers) {
+    const id = new IdentifierWASM(identifier);
+    const tokenIds = tokenIdentifiers.map(tokenIdentifier => new IdentifierWASM(tokenIdentifier));
+    const getIdentityTokenBalancesRequest = GetIdentityTokenBalancesRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenIds: tokenIds.map((identifier) => identifier.bytes()),
+                identityId: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityTokenBalances(getIdentityTokenBalancesRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, balances } = verifyTokensBalancesForIdentityProof(proof.grovedbProof, tokenIds, id, true, PlatformVersionWASM.PLATFORM_V9);
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
+    const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return balances
+        .map((tokenBalance) => ({
+        tokenId: new IdentifierWASM(tokenBalance.tokenId),
+        balance: tokenBalance.balance
+    }));
+}

package/src/tokens/getTokenContractInfo.js

@@ -0,0 +1,43 @@
+import { GetTokenContractInfoRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenContractInfoProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getTokenContractInfo(grpcPool, tokenIdentifier) {
+    const tokenId = new IdentifierWASM(tokenIdentifier);
+    const getTokenContractInfoRequest = GetTokenContractInfoRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenId: (tokenId).bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTokenContractInfo(getTokenContractInfoRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, contractInfo } = verifyTokenContractInfoProof(proof.grovedbProof, tokenId, true, PlatformVersionWASM.PLATFORM_V9);
+    if (contractInfo == null) {
+        throw new Error('ContractInfo not found');
+    }
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
+    const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return {
+        dataContractId: contractInfo.contractId,
+        tokenContractPosition: contractInfo.tokenContractPosition
+    };
+}

package/src/tokens/getTokenDirectPurchasePrices.js

@@ -0,0 +1,40 @@
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenDirectPurchasePrices } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import bytesToHex from '../utils/bytesToHex';
+import { GetTokenDirectPurchasePricesRequest } from '../../proto/generated/platform';
+export default async function getTokenDirectPurchasePrices(grpcPool, tokenIdentifiers) {
+    const tokenIds = tokenIdentifiers.map(tokenId => new IdentifierWASM(tokenId).bytes());
+    const request = GetTokenDirectPurchasePricesRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenIds,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTokenDirectPurchasePrices(request);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, prices } = verifyTokenDirectPurchasePrices(proof.grovedbProof, tokenIds, true, PlatformVersionWASM.PLATFORM_V9);
+    if (prices == null) {
+        throw new Error('Prices not found');
+    }
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
+    const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return prices;
+}

package/src/tokens/getTokenTotalSupply.js

@@ -0,0 +1,41 @@
+import { GetTokenTotalSupplyRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyTokenTotalSupplyProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getTokenTotalSupply(grpcPool, tokenIdentifier) {
+    const tokenId = new IdentifierWASM(tokenIdentifier);
+    const getTokenTotalSupplyRequest = GetTokenTotalSupplyRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                tokenId: (tokenId).bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getTokenTotalSupply(getTokenTotalSupplyRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, totalBalance } = verifyTokenTotalSupplyProof(proof.grovedbProof, tokenId, true, PlatformVersionWASM.PLATFORM_V9);
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
+    const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return {
+        tokenId,
+        totalSystemAmount: totalBalance.tokenSupply,
+        totalAggregatedAmountInUserAccounts: totalBalance.aggregatedTokenAccountBalances
+    };
+}

package/src/tokens/index.js

@@ -0,0 +1,108 @@
+import getIdentitiesTokenBalances from './getIdentitiesTokenBalances';
+import getIdentityTokensBalances from './getIdentityTokensBalances';
+import getTokenContractInfo from './getTokenContractInfo';
+import getTokenTotalSupply from './getTokenTotalSupply';
+import createStateTransition from './createStateTransition';
+import { IdentifierWASM, TokenBaseTransitionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
+import getIdentityContractNonce from '../identities/getIdentityContractNonce';
+import getTokenDirectPurchasePrices from './getTokenDirectPurchasePrices';
+/**
+ * Tokens controller for requesting information about tokens and tokens holders
+ *
+ * @hideconstructor
+ */
+export class TokensController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Retrieves a token balances for identities
+     *
+     * @param identifiers {IdentifierLike[]} - list of identifiers which balance we need to get
+     * @param tokenIdentifier {IdentifierLike} - token identifier
+     *
+     * @return {Promise<IdentitiesTokenBalances>}
+     */
+    async getIdentitiesTokenBalances(identifiers, tokenIdentifier) {
+        return await getIdentitiesTokenBalances(this.grpcPool, identifiers, tokenIdentifier);
+    }
+    /**
+     * Retrieves a tokens balances for identity
+     *
+     * @param identifier {IdentifierLike} - identifier which balance we need to get
+     * @param tokenIdentifiers {IdentifierLike[]} - list of tokens ids which used in request
+     *
+     * @return {Promise<IdentityTokenBalances>}
+     */
+    async getIdentityTokensBalances(identifier, tokenIdentifiers) {
+        return await getIdentityTokensBalances(this.grpcPool, identifier, tokenIdentifiers);
+    }
+    /**
+     * Retrieves a tokens contract info by id
+     *
+     * @param tokenIdentifier {IdentifierLike} - token id which contract info we need
+     *
+     * @return {Promise<TokenContractInfo>}
+     */
+    async getTokenContractInfo(tokenIdentifier) {
+        return await getTokenContractInfo(this.grpcPool, tokenIdentifier);
+    }
+    /**
+     * Retrieves a token total supply
+     *
+     * @param tokenIdentifier {IdentifierLike} - token id which total supply we need
+     *
+     * @return {Promise<TokenTotalSupply>}
+     */
+    async getTokenTotalSupply(tokenIdentifier) {
+        return await getTokenTotalSupply(this.grpcPool, tokenIdentifier);
+    }
+    /**
+     * Retrieves a tokens prices
+     *
+     * @param tokenIdentifiers {IdentifierLike[]} - token ids which price we need
+     *
+     * @return {Promise<TokenDirectPurchasePrices[]>}
+     */
+    async getTokensDirectPurchasePrice(tokenIdentifiers) {
+        return await getTokenDirectPurchasePrices(this.grpcPool, tokenIdentifiers);
+    }
+    /**
+     * Creates a Token Base Transition that contains base information about token transition
+     *
+     * @param tokenId {IdentifierLike} - token identifier
+     * @param ownerId {IdentifierLike} - identity identifier of sender of the transaction
+     *
+     * @return {TokenBaseTransitionWASM}
+     */
+    async createBaseTransition(tokenId, ownerId) {
+        const { dataContractId, tokenContractPosition } = await getTokenContractInfo(this.grpcPool, tokenId);
+        const identityContractNonce = await getIdentityContractNonce(this.grpcPool, ownerId, dataContractId);
+        return new TokenBaseTransitionWASM(identityContractNonce + BigInt(1), tokenContractPosition, dataContractId, tokenId, undefined);
+    }
+    /**
+     * Helper function for creation of a token state transition to be broadcasted in the network
+     *
+     * You have to pass token base transition acquired from .createBaseTransition() method
+     * together with token transition type and its params
+     *
+     * @param base {TokenBaseTransitionWASM} - token Base transition
+     * @param ownerId {IdentifierLike} - `identity identifier of the owner of the transaction`
+     * @param type {TokenTransitionType} - token transition type as string (f.e. 'transfer')
+     * @param params {TokenTransitionParams} - params required for a token transition
+     *
+     * @return {StateTransitionWASM}
+     */
+    createStateTransition(base, ownerId, type, params) {
+        const owner = new IdentifierWASM(ownerId);
+        if (params.identityId != null) {
+            params.identityId = new IdentifierWASM(params.identityId);
+        }
+        if (params.price != null && typeof params.price === 'bigint') {
+            params.price = TokenPricingScheduleWASM.SinglePrice(params.price);
+        }
+        return createStateTransition(base, owner, type, params);
+    }
+}

package/src/types.js

@@ -0,0 +1,15 @@
+export { IdentifierWASM, IdentityWASM, DocumentWASM, DataContractWASM, StateTransitionWASM, IdentityPublicKeyWASM } from 'pshenmic-dpp';
+export { DashPlatformSDK } from './DashPlatformSDK';
+export var ContestedStateResultType;
+(function (ContestedStateResultType) {
+    ContestedStateResultType[ContestedStateResultType["DOCUMENTS"] = 0] = "DOCUMENTS";
+    ContestedStateResultType[ContestedStateResultType["VOTE_TALLY"] = 1] = "VOTE_TALLY";
+    ContestedStateResultType[ContestedStateResultType["DOCUMENTS_AND_VOTE_TALLY"] = 2] = "DOCUMENTS_AND_VOTE_TALLY";
+})(ContestedStateResultType || (ContestedStateResultType = {}));
+export var FinishedVoteOutcome;
+(function (FinishedVoteOutcome) {
+    FinishedVoteOutcome[FinishedVoteOutcome["TOWARDS_IDENTITY"] = 0] = "TOWARDS_IDENTITY";
+    FinishedVoteOutcome[FinishedVoteOutcome["LOCKED"] = 1] = "LOCKED";
+    FinishedVoteOutcome[FinishedVoteOutcome["NO_PREVIOUS_WINNER"] = 2] = "NO_PREVIOUS_WINNER";
+    FinishedVoteOutcome[FinishedVoteOutcome["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(FinishedVoteOutcome || (FinishedVoteOutcome = {}));

package/src/utils/base58ToBytes.js

@@ -0,0 +1,4 @@
+import { base58 } from '@scure/base';
+export default function base58ToBytes(str) {
+    return base58.decode(str);
+}

package/src/utils/bytesToHex.js

@@ -0,0 +1,3 @@
+export default function bytesToHex(bytes) {
+    return Array.prototype.map.call(bytes, (x) => ('00' + x.toString(16)).slice(-2)).join('');
+}

package/src/utils/bytesToTypedArray.js

@@ -0,0 +1,3 @@
+export function typedArrayToBuffer(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteLength + bytes.byteOffset);
+}

package/src/utils/calculateMsgHash.js

@@ -0,0 +1,31 @@
+import sha256 from './sha256';
+export async function calculateMsgHash(chainId, height, round, type, blockId, stateId) {
+    const fixedSize = 4 + 8 + 8 + 32 + 32;
+    const chainIdBytes = new TextEncoder().encode(chainId);
+    const totalSize = fixedSize + chainIdBytes.length;
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    const uint8View = new Uint8Array(buffer);
+    let offset = 0;
+    // Write type as 32-bit little-endian integer
+    view.setInt32(offset, type, true);
+    offset += 4;
+    // Write height as 64-bit little-endian integer
+    view.setBigUint64(offset, height, true);
+    offset += 8;
+    // Write round as 64-bit little-endian integer
+    view.setBigUint64(offset, BigInt(round), true);
+    offset += 8;
+    // Copy blockId (32 bytes)
+    uint8View.set(blockId, offset);
+    offset += 32;
+    // Copy stateId (32 bytes)
+    uint8View.set(stateId, offset);
+    offset += 32;
+    if (offset !== fixedSize) {
+        throw new Error('Invalid input length while encoding sign bytes');
+    }
+    // Copy chainId bytes
+    uint8View.set(chainIdBytes, offset);
+    return await sha256(uint8View);
+}

package/src/utils/calculateSignHash.js

@@ -0,0 +1,8 @@
+import { calculateMsgHash } from './calculateMsgHash';
+import signRequestId from './signRequestId';
+import signHash from './signHash';
+export async function calculateSignHash(commit, chainId, quorumType, quorumHash, height, round) {
+    const requestId = await signRequestId('dpbvote', height, round);
+    const signBytesHash = await calculateMsgHash(chainId, height, round, commit.type, commit.blockId, commit.stateId);
+    return await signHash(quorumType, quorumHash, requestId, signBytesHash);
+}

package/src/utils/calculateStateIdHash.js

@@ -0,0 +1,10 @@
+import { StateId } from '../../proto/generated/platform';
+import sha256 from './sha256';
+import { BinaryWriter } from '@bufbuild/protobuf/wire';
+export async function calculateStateIdHash(stateId) {
+    const writer = new BinaryWriter();
+    // @ts-expect-error
+    const encoded = StateId.internalBinaryWrite(stateId, writer, { writeUnknownFields: false }).finish();
+    writer.bytes(encoded);
+    return await sha256(writer.finish());
+}

package/src/utils/convertToHomographSafeChars.js

@@ -0,0 +1,11 @@
+export default function convertToHomographSafeChars(input) {
+    return input.toLowerCase().replace(/[oli]/g, (match) => {
+        if (match === 'o') {
+            return '0';
+        }
+        if (match === 'l' || match === 'i') {
+            return '1';
+        }
+        return match;
+    });
+}

package/src/utils/createVoterIdentityId.js

@@ -0,0 +1,13 @@
+import { IdentifierWASM } from 'pshenmic-dpp';
+import sha256 from './sha256';
+import bytesToHex from './bytesToHex';
+import hexToBytes from './hexToBytes';
+export async function createVoterIdentityId(proTxHash, publicKeyHash) {
+    const proTxHashBytes = hexToBytes(proTxHash);
+    const publicKeyHashBytes = hexToBytes(publicKeyHash);
+    const mergedArray = new Uint8Array(proTxHashBytes.length + publicKeyHashBytes.length);
+    mergedArray.set(proTxHashBytes);
+    mergedArray.set(publicKeyHashBytes, proTxHashBytes.length);
+    const voterIdentifierBytes = await sha256(mergedArray);
+    return IdentifierWASM.fromHex(bytesToHex(voterIdentifierBytes));
+}

package/src/utils/getEvonodeList.js

@@ -0,0 +1,12 @@
+export default async function getDAPINodeList(network) {
+    const url = `https://${network === 'mainnet' ? '' : 'testnet.'}platform-explorer.pshenmic.dev/validators?isActive=true`;
+    const resp = await fetch(url);
+    if (resp.status !== 200) {
+        throw new Error('Failed to query Platform Explorer for active validators');
+    }
+    const { resultSet } = await resp.json();
+    return resultSet
+        // eslint-disable-next-line
+        .map((validator) => validator?.proTxInfo?.state?.service ? `https://${validator.proTxInfo.state.service.split(':')[0]}${network === 'mainnet' ? '' : ':1443'}` : undefined)
+        .filter(e => e != null);
+}

package/src/utils/getQuorumPublicKey.js

@@ -0,0 +1,18 @@
+const cache = {};
+export async function getQuorumPublicKey(network, quorumType, quorumHash) {
+    const cached = cache[`${quorumType}_${quorumHash}`];
+    if (cached != null) {
+        return cached;
+    }
+    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

@@ -0,0 +1,3 @@
+export default function getRandomArrayItem(array) {
+    return array[Math.floor((Math.random() * array.length))];
+}

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

@@ -0,0 +1,3 @@
+export default function hexToBytes(hex) {
+    return Uint8Array.from((hex.match(/.{1,2}/g) ?? []).map((byte) => parseInt(byte, 16)));
+}

package/src/utils/index.js

@@ -0,0 +1,61 @@
+import convertToHomographSafeChars from './convertToHomographSafeChars';
+import { base58 } from '@scure/base';
+import hexToBytes from './hexToBytes';
+import bytesToHex from './bytesToHex';
+/**
+ * Collection of conversion functions
+ *
+ * @hideconstructor
+ */
+export class UtilsController {
+    /**
+     * Converts base58 string to an Uint8Array
+     *
+     * @param str {string}
+     *
+     * @returns {Uint8Array}
+     */
+    base58ToBytes(str) {
+        return base58.decode(str);
+    }
+    /**
+     * Converts Uint8Array to base58 string
+     *
+     * @param bytes {Uint8Array}
+     *
+     * @return {string}
+     */
+    bytesToBase58(bytes) {
+        return base58.encode(bytes);
+    }
+    /**
+     * Converts Uint8Array to hex string
+     *
+     * @param bytes {Uint8Array}
+     *
+     * @return {string}
+     */
+    bytesToHex(bytes) {
+        return bytesToHex(bytes);
+    }
+    /**
+     * Converts a hex string to Uint8Array
+     *
+     * @param hex {string} hex-encoded string
+     *
+     * @return {Uint8Array}
+     */
+    hexToBytes(hex) {
+        return hexToBytes(hex);
+    }
+    /**
+     * @deprecated use sdk.names.normalizeLabel()
+     *
+     * @param str {string}
+     *
+     * @return {string}
+     */
+    convertToHomographSafeChars(str) {
+        return convertToHomographSafeChars(str);
+    }
+}

package/src/utils/indexBytesToString.js

@@ -0,0 +1,4 @@
+export default function indexValueBytesToString(value) {
+    const decoder = new TextDecoder();
+    return decoder.decode(value).slice(2);
+}

package/src/utils/sha256.js

@@ -0,0 +1,15 @@
+import bytesToHex from './bytesToHex';
+import { typedArrayToBuffer } from './bytesToTypedArray';
+export default async function sha256(input) {
+    if (typeof input === 'string') {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(input);
+        const hash = await crypto.subtle.digest('SHA-256', data);
+        return bytesToHex(new Uint8Array(hash));
+    }
+    else {
+        const arrayBuffer = typedArrayToBuffer(input);
+        const hash = await crypto.subtle.digest('SHA-256', arrayBuffer);
+        return new Uint8Array(hash);
+    }
+}

package/src/utils/signHash.js

@@ -0,0 +1,22 @@
+import sha256 from './sha256';
+export default async function signHash(quorumType, quorumHash, requestId, signBytesHash) {
+    // Calculate total length: 1 byte for quorumType + 3 arrays of 32 bytes each
+    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
+    const reversedQuorumHash = new Uint8Array(quorumHash).reverse();
+    combined.set(reversedQuorumHash, offset);
+    offset += quorumHash.length;
+    // Add reversed requestId
+    const reversedRequestId = new Uint8Array(requestId).reverse();
+    combined.set(reversedRequestId, offset);
+    offset += requestId.length;
+    // Add reversed signBytesHash
+    const reversedSignBytesHash = new Uint8Array(signBytesHash).reverse();
+    combined.set(reversedSignBytesHash, offset);
+    return await sha256(await sha256(combined));
+}

package/src/utils/signRequestId.js

@@ -0,0 +1,19 @@
+import sha256 from './sha256';
+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)
+    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;
+    // Write height as 64-bit little-endian integer
+    view.setBigUint64(offset, height, true);
+    offset += 8;
+    // Write round as 32-bit little-endian integer
+    view.setInt32(offset, round, true);
+    return await sha256(uint8View);
+}

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

@@ -0,0 +1,10 @@
+export default function stringToIndexValueBytes(name) {
+    const lengthBuffer = new Uint8Array(1);
+    lengthBuffer[0] = name.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);
+    return result;
+}

package/src/utils/verifyTenderdashProof.js

@@ -0,0 +1,26 @@
+import { CanonicalVote, SignedMsgType, StateId } from '../../proto/generated/platform';
+import { calculateSignHash } from './calculateSignHash';
+import { calculateStateIdHash } from './calculateStateIdHash';
+import { verifySignatureDigest } from 'pshenmic-dpp';
+import hexToBytes from './hexToBytes';
+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
+    });
+    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
+    });
+    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.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.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);
+}