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

package/src/types.d.ts

@@ -2,9 +2,9 @@ import { DocumentWASM, GasFeesPaidByWASM, IdentifierWASM, KeyType, Purpose, Secu
 export { IdentifierWASM, IdentityWASM, DocumentWASM, DataContractWASM, StateTransitionWASM, IdentityPublicKeyWASM } from 'pshenmic-dpp';
 export type IdentifierLike = IdentifierWASM | string | Uint8Array;
 export type Network = 'mainnet' | 'testnet';
-export { DashPlatformSDK } from './DashPlatformSDK';
+export { DashPlatformSDK } from './DashPlatformSDK.js';
 export type MasternodeList = Record<string, MasternodeInfo>;
-export { AbstractSigner } from './signer/AbstractSigner';
+export { AbstractSigner } from './signer/AbstractSigner.js';
 export interface DocumentTransitionParams {
     identityContractNonce: bigint;
     amount?: bigint;

package/src/types.js

@@ -0,0 +1,15 @@
+export { IdentifierWASM, IdentityWASM, DocumentWASM, DataContractWASM, StateTransitionWASM, IdentityPublicKeyWASM } from 'pshenmic-dpp';
+export { DashPlatformSDK } from './DashPlatformSDK.js';
+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.js';
+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.d.ts

@@ -1,2 +1,2 @@
-import { CanonicalVote } from '../../proto/generated/platform';
+import { CanonicalVote } from '../../proto/generated/platform.js';
 export declare function calculateSignHash(commit: CanonicalVote, chainId: string, quorumType: number, quorumHash: Uint8Array, height: bigint, round: number): Promise<Uint8Array>;

package/src/utils/calculateSignHash.js

@@ -0,0 +1,8 @@
+import { calculateMsgHash } from './calculateMsgHash.js';
+import signRequestId from './signRequestId.js';
+import signHash from './signHash.js';
+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.d.ts

@@ -1,2 +1,2 @@
-import { StateId } from '../../proto/generated/platform';
+import { StateId } from '../../proto/generated/platform.js';
 export declare function calculateStateIdHash(stateId: StateId): Promise<Uint8Array>;

package/src/utils/calculateStateIdHash.js

@@ -0,0 +1,10 @@
+import { StateId } from '../../proto/generated/platform.js';
+import sha256 from './sha256.js';
+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.js';
+import bytesToHex from './bytesToHex.js';
+import hexToBytes from './hexToBytes.js';
+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.d.ts

@@ -1,2 +1,2 @@
-import { MasternodeList, Network } from '../types';
+import { MasternodeList, Network } from '../types.js';
 export default function getDAPINodeList(network: Network): Promise<MasternodeList>;

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.js';
+import { base58 } from '@scure/base';
+import hexToBytes from './hexToBytes.js';
+import bytesToHex from './bytesToHex.js';
+/**
+ * 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.js';
+import { typedArrayToBuffer } from './bytesToTypedArray.js';
+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.js';
+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.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)
+    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.d.ts

@@ -1,2 +1,2 @@
-import { Proof, ResponseMetadata } from '../../proto/generated/platform';
+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

@@ -0,0 +1,26 @@
+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
+    });
+    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);
+}

package/src/voting/index.d.ts

@@ -1,4 +1,4 @@
-import { IdentifierLike, ResourceVoteChoice } from '../types';
+import { IdentifierLike, ResourceVoteChoice } from '../types.js';
 import { IdentifierWASM, StateTransitionWASM, VoteWASM } from 'pshenmic-dpp';
 /**
  * Voting controller for performing masternode votes

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 masternoe protxhash and voter identity
+       *
+       * @param voteWASM {VoteWASM} vote instance from .createMsternodeVote() 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();
+    }
+}