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

package/src/DashPlatformSDK.d.ts

@@ -11,12 +11,13 @@ import { ContestedResourcesController } from './contestedResources';
 import { TokensController } from './tokens';
 import { AbstractSigner } from './signer/AbstractSigner';
 import { VotingController } from './voting';
+import { Network } from './types';
 export interface GRPCOptions {
     poolLimit: 5;
     dapiUrl?: string | string[];
 }
 export interface SDKOptions {
-    network: 'testnet' | 'mainnet';
+    network: Network;
     grpc?: GRPCOptions;
     /** @deprecated Use {GRPCOptions} instead, will be removed in next major version **/
     dapiUrl?: string | string[];
@@ -26,7 +27,7 @@ export interface SDKOptions {
  * Javascript SDK for that let you interact with a Dash Platform blockchain
  */
 export declare class DashPlatformSDK {
-    network: 'testnet' | 'mainnet';
+    network: Network;
     /** @ignore **/
     grpcPool: GRPCConnectionPool;
     /** @ignore **/
@@ -58,7 +59,7 @@ export declare class DashPlatformSDK {
      * @param grpcPool
      * @param network
      */
-    _initialize(grpcPool: GRPCConnectionPool, network: 'testnet' | 'mainnet'): void;
+    _initialize(grpcPool: GRPCConnectionPool, network: Network): void;
     setSigner(signer: AbstractSigner): void;
     /**
      * Get currently used network
@@ -71,5 +72,5 @@ export declare class DashPlatformSDK {
      *
      * @param network {string}
      */
-    setNetwork(network: 'testnet' | 'mainnet'): void;
+    setNetwork(network: Network): void;
 }

package/src/contestedResources/createStateTransition.d.ts

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

package/src/grpcConnectionPool.d.ts

@@ -1,10 +1,32 @@
-import { Channel, Client } from 'nice-grpc-web';
-import { PlatformDefinition } from '../proto/generated/platform';
-import { GRPCOptions } from './DashPlatformSDK';
+import { PlatformClient } from '../proto/generated/platform.client';
+import { Network } from './types';
+export type MasternodeList = Record<string, MasternodeInfo>;
+export interface GRPCOptions {
+    poolLimit: 5;
+    dapiUrl?: string | string[];
+}
+export interface MasternodeInfo {
+    proTxHash: string;
+    address: string;
+    payee: string;
+    status: string;
+    type: string;
+    platformNodeID: string;
+    platformP2PPort: number;
+    platformHTTPPort: number;
+    pospenaltyscore: number;
+    consecutivePayments: number;
+    lastpaidtime: number;
+    lastpaidblock: number;
+    owneraddress: string;
+    votingaddress: string;
+    collateraladdress: string;
+    pubkeyoperator: string;
+}
 export default class GRPCConnectionPool {
-    channels: Channel[];
-    network: string;
-    constructor(network: 'testnet' | 'mainnet', grpcOptions?: GRPCOptions);
-    _initialize(network: 'testnet' | 'mainnet', poolLimit: number, dapiUrl?: string | string[]): Promise<void>;
-    getClient(): Client<PlatformDefinition>;
+    dapiUrls: string[];
+    network: Network;
+    constructor(network: Network, grpcOptions?: GRPCOptions);
+    _initialize(network: Network, poolLimit: number, dapiUrl?: string | string[]): Promise<void>;
+    getClient(abortController?: AbortController): PlatformClient;
 }

package/src/keyPair/deriveChild.d.ts

@@ -1,2 +1,2 @@
-import { HDKey } from 'dashhd';
-export default function deriveChild(parent: HDKey, index: number, hardened: boolean): Promise<HDKey>;
+import { HDKey } from '@scure/bip32';
+export default function deriveChild(hdKey: HDKey, index: number): HDKey;

package/src/keyPair/derivePath.d.ts

@@ -1,2 +1,2 @@
-import { HDKey } from 'dashhd';
-export default function derivePath(parent: HDKey, path: string): Promise<HDKey>;
+import { HDKey } from '@scure/bip32';
+export default function derivePath(hdKey: HDKey, path: string): HDKey;

package/src/keyPair/index.d.ts

@@ -1,142 +1,67 @@
-import { HDFromSeedOptions, HDFromXKeyOptions, HDKey, HDWallet, HDXKey } from 'dashhd';
-import { NetworkVersion, WalletToIdentityKeyOpts } from '../types';
+import { HDKey } from '@scure/bip32';
+import { Network } from '../types';
 /**
  * Collection of functions to work with private keys and seed phrases
  *
  * @hideconstructor
  */
 export declare class KeyPairController {
-    /**
-     * Allows to derive child HD Key
-     *
-     * @param parent {HDKey} - The HDKey parent instance
-     * @param index {number} - Index of child
-     * @param hardened {boolean} - hardened or no
-     *
-     * @return {Promise<HDKey>} A promise that resolves child key
-     */
-    deriveChild(parent: HDKey, index: number, hardened: boolean): Promise<HDKey>;
-    /**
-     * Allows to derive HD key by path
-     *
-     * @param parent {HDKey} - The HDKey parent instance
-     * @param path {string} - Path of children
-     *
-     * @return {Promise<HDKey>} A promise that resolves key by path
-     */
-    derivePath(parent: HDKey, path: string): Promise<HDKey>;
-    /**
-     * Convert a HDKey to a public key
-     *
-     * @param hdKey {HDKey} - The HDKey to be converted into a public key
-     * @param opts {NetworkVersion=} - Network version
-     *
-     * @return {Promise<Uint8Array>} - converted public key
-     */
-    keyToPublicKey(hdKey: HDKey, opts?: NetworkVersion): Promise<Uint8Array>;
-    /**
-     * Converts a HDKey to a wallet ID
-     *
-     * @param hdKey {HDKey} - The HDKey to be converted into a wallet id.
-     *
-     * @return {Promise<string>} Wallet id from used key
-     */
-    keyToWalletId(hdKey: HDKey): Promise<string>;
-    /**
-     * Converts an HDKey instance to an extended private key (xprv)
-     *
-     * @param hdKey {HDKey} - The HDKey instance to convert
-     * @param opts {NetworkVersion=} - Optional, containing the version
-     *
-     * @returns {Promise<string>} A promise that resolves to the xPrivateKey string
-     */
-    keyToXPrivateKey(hdKey: HDKey, opts?: NetworkVersion): Promise<string>;
-    /**
-     * Convert a HDKey to a xPublicKey
-     * @param hdKey {HDKey} - The HDKey instance to convert
-     * @param opts {NetworkVersion=} - Optional, containing the version
-     *
-     * @return {Promise<Uint8Array>}
-     */
-    keyToXPublicKey(hdKey: HDKey, opts?: NetworkVersion): Promise<Uint8Array>;
-    /**
-     * Derives an Identity HDKey from a mnemonic phrase.
-     *
-     * @param mnemonic {string} - The BIP39 mnemonic phrase.
-     * @param identityIndex {number} - The identity index (default: 0).
-     * @param keyIndex {number} - The key index within the identity (default: 0).
-     * @param salt {string=} - Optional salt for seed derivation.
-     * @param verify {boolean=} - Whether to verify the mnemonic during derivation.
-     * @param opts {(HDFromSeedOptions & WalletToIdentityKeyOpts)=} - Additional options for HD seed derivation and wallet-to-identity conversion.
-     *
-     * @returns {Promise<HDKey>} A promise that resolves to the derived identity HDKey.
-     */
-    mnemonicToIdentityKey(mnemonic: string, identityIndex?: number, keyIndex?: number, salt?: string, verify?: boolean, opts?: HDFromSeedOptions & WalletToIdentityKeyOpts): Promise<HDKey>;
     /**
      * Returns seed from mnemonic phrase
      *
      * @param mnemonic {string} - The BIP39 mnemonic phrase.
      * @param salt {string=} -  Optional salt for seed derivation.
-     * @param verify {boolean=} - Whether to verify the mnemonic during derivation.
      *
-     * @return {Promise<Uint8Array>} Seed bytes
+     * @return {Uint8Array} Seed bytes
      */
-    mnemonicToSeed(mnemonic: string, salt?: string, verify?: boolean): Promise<Uint8Array>;
+    mnemonicToSeed(mnemonic: string, salt?: string): Uint8Array;
     /**
-     * Returns wallet from mnemonic phrase
+     * Returns seed from mnemonic phrase
      *
-     * @param mnemonic {string} - The BIP39 mnemonic phrase.
-     * @param salt {string=} - Optional salt for seed derivation.
-     * @param verify {boolean=} - Whether to verify the mnemonic during derivation.
-     * @param opts {HDFromSeedOptions=} - Optional derivation settings
+     * @param seed {Uint8Array}
+     * @param network {Network} network
      *
-     * @return {Promise<HDWallet>} Wallet from mnemonic
+     * @return {HDKey} HDKey
      */
-    mnemonicToWallet(mnemonic: string, salt?: string, verify?: boolean, opts?: HDFromSeedOptions): Promise<HDKey>;
+    seedToHdKey(seed: Uint8Array, network?: Network): HDKey;
     /**
-     * Convert a private key to WIF
-     *
-     * @param privateKeyBytes {Uint8Array} - Private key bytes
-     * @param opts {NetworkVersion=} - Optional options with network version
-     *
-     * @return {Promise<string>} WIF
-     */
-    privateKeyToWif(privateKeyBytes: Uint8Array, opts?: NetworkVersion): Promise<string>;
+       * Allows to derive child HD Key
+       *
+       * @param hdKey {HDKey} - The HDKey parent instance
+       * @param index {number} - Index of child
+       *
+       * @return {Promise<HDKey>} A promise that resolves child key
+       */
+    deriveChild(hdKey: HDKey, index: number): Promise<HDKey>;
     /**
-     * Convert public key to address
-     *
-     * @param publicKeyBytes {Uint8Array} - Bytes of public key
-     * @param opts {NetworkVersion=} - Optional options with network version
-     *
-     * @return {Promise<string>} address string
-     */
-    publicKeyToAddress(publicKeyBytes: Uint8Array, opts?: NetworkVersion): Promise<string>;
+       * Allows to derive HD key by path
+       *
+       * @param hdKey {HDKey} - The HDKey parent instance
+       * @param path {string} - Path of children
+       *
+       * @return {Promise<HDKey>} A promise that resolves key by path
+       */
+    derivePath(hdKey: HDKey, path: string): Promise<HDKey>;
     /**
-     * Convert seed bytes to wallet
+     * Derives an {HDKey} child by identity index and key index from an {HDKey}
      *
-     * @param seed {Uint8Array} - seed bytes
-     * @param opts {HDFromSeedOptions?} - Optional options with network version
+     * Usually used to get a identity private key from seed
      *
-     * @return {Promise<HDWallet>}
-     */
-    seedToWallet(seed: Uint8Array, opts?: HDFromSeedOptions): Promise<HDWallet>;
-    /**
-     * Returns identity key from wallet
+     * @param hdKey {HDKey}
+     * @param identityIndex {number}
+     * @param keyIndex {number}
+     * @param network {Network}
      *
-     * @param wallet {HDWallet | HDKey} - wallet that will be used
-     * @param identityIndex {number} - index of identity for wallet
-     * @param keyIndex {number} - index of key for identity
-     * @param opts {WalletToIdentityKeyOpts=} - optional options
-     *
-     * @return {Promise<HDKey>}
+     * @returns {HDKey}
      */
-    walletToIdentityKey(wallet: HDWallet | HDKey, identityIndex: number, keyIndex: number, opts?: WalletToIdentityKeyOpts): Promise<HDKey>;
+    deriveIdentityPrivateKey(hdKey: HDKey, identityIndex: number, keyIndex: number, network: Network): HDKey;
     /**
-     * Allows to convert xKey to HDXKey
+     * Converts {PublicKey} to a Dash network address (P2PKH)
+     *
+     * @param publicKey {Uint8Array}
+     * @param network {Network}
      *
-     * @param xKey {string} - String with xKey
-     * @param opts {HDFromXKeyOptions=} - Optional options
-     * @return {Promise<HDXKey>}
+     * @returns {string}
      */
-    xKeyToHDXKey(xKey: string, opts?: HDFromXKeyOptions): Promise<HDXKey>;
+    p2pkhAddress(publicKey: Uint8Array, network: Network): string;
 }

package/src/keyPair/mnemonicToSeed.d.ts

@@ -1 +1 @@
-export default function mnemonicToSeed(mnemonic: string, salt?: string, verify?: boolean): Promise<Uint8Array>;
+export default function mnemonicToSeed(mnemonic: string, salt?: string): Uint8Array;

package/src/names/searchByIdentity.d.ts

@@ -1,3 +1,3 @@
 import { DocumentWASM, IdentifierWASM } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool';
-export default function search(grpcPool: GRPCConnectionPool, identifier: IdentifierWASM): Promise<DocumentWASM[]>;
+export default function searchByIdentity(grpcPool: GRPCConnectionPool, identifier: IdentifierWASM): Promise<DocumentWASM[]>;

package/src/node/index.d.ts

@@ -1,5 +1,5 @@
 import GRPCConnectionPool from '../grpcConnectionPool';
-import { NodeStatus } from '../types';
+import { Network, NodeStatus } from '../types';
 import { EpochInfo } from './epochs';
 /**
  * Node controller for requesting information about DAPI node
@@ -9,8 +9,8 @@ import { EpochInfo } from './epochs';
 export declare class NodeController {
     /** @ignore **/
     grpcPool: GRPCConnectionPool;
-    network: 'testnet' | 'mainnet';
-    constructor(grpcPool: GRPCConnectionPool, network: 'testnet' | 'mainnet');
+    network: Network;
+    constructor(grpcPool: GRPCConnectionPool, network: Network);
     /**
      * Retrieves an info about node
      * Includes information about genesis, chain, software versions

package/src/node/totalCredits.d.ts

@@ -1,2 +1,3 @@
 import GRPCConnectionPool from '../grpcConnectionPool';
-export default function totalCredits(grpcPool: GRPCConnectionPool, network: 'testnet' | 'mainnet'): Promise<bigint>;
+import { Network } from '../types';
+export default function totalCredits(grpcPool: GRPCConnectionPool, network: Network): Promise<bigint>;

package/src/types.d.ts

@@ -1,16 +1,10 @@
 import { DocumentWASM, GasFeesPaidByWASM, IdentifierWASM, KeyType, Purpose, SecurityLevel, TokenEmergencyActionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
-import { Versions } from 'dashhd';
 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 type MasternodeList = Record<string, MasternodeInfo>;
 export { AbstractSigner } from './signer/AbstractSigner';
-export interface WalletToIdentityKeyOpts {
-    network?: 'mainnet' | 'testnet';
-}
-export interface NetworkVersion {
-    version: Versions;
-}
 export interface DocumentTransitionParams {
     identityContractNonce: bigint;
     amount?: bigint;
@@ -48,17 +42,17 @@ export interface MasternodeInfo {
 }
 export interface NodeStatus {
     version: {
-        software: {
+        software?: {
             dapi: string;
             drive?: string | undefined;
             tenderdash?: string | undefined;
         } | undefined;
-        protocol: {
-            tenderdash: {
-                p2p: number;
+        protocol?: {
+            tenderdash?: {
+                p2P: number;
                 block: number;
             } | undefined;
-            drive: {
+            drive?: {
                 latest: number;
                 current: number;
             } | undefined;

package/src/utils/bytesToTypedArray.d.ts

@@ -0,0 +1 @@
+export declare function typedArrayToBuffer(bytes: Uint8Array): ArrayBuffer;

package/src/utils/calculateMsgHash.d.ts

@@ -1 +1 @@
-export declare function calculateMsgHash(chainId: string, height: bigint, round: number, type: number, blockId: Uint8Array, stateId: Uint8Array): Uint8Array;
+export declare function calculateMsgHash(chainId: string, height: bigint, round: number, type: number, blockId: Uint8Array, stateId: Uint8Array): Promise<Uint8Array>;

package/src/utils/calculateSignHash.d.ts

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

package/src/utils/calculateStateIdHash.d.ts

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

package/src/utils/createVoterIdentityId.d.ts

@@ -1,2 +1,2 @@
 import { IdentifierWASM } from 'pshenmic-dpp';
-export declare function createVoterIdentityId(proTxHash: string, publicKeyHash: string): IdentifierWASM;
+export declare function createVoterIdentityId(proTxHash: string, publicKeyHash: string): Promise<IdentifierWASM>;

package/src/utils/getEvonodeList.d.ts

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

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/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/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/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;
+export default function verifyTenderdashProof(proof: Proof, metadata: ResponseMetadata, rootHash: Uint8Array, quorumPublicKey: string): Promise<boolean>;

package/src/voting/createStateTransition.d.ts

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

package/src/voting/index.d.ts

@@ -1,6 +1,5 @@
 import { IdentifierLike, ResourceVoteChoice } from '../types';
-import { IdentifierWASM, StateTransitionWASM } from 'pshenmic-dpp';
-import { VoteWASM } from 'pshenmic-dpp/dist/wasm/pshenmic_dpp';
+import { IdentifierWASM, StateTransitionWASM, VoteWASM } from 'pshenmic-dpp';
 /**
  * Voting controller for performing masternode votes
  *
@@ -13,9 +12,9 @@ export declare class VotingController {
      * @param proTxHash {string} voter's masternode pro tx hash
      * @param publicKeyHash {string} voter address's public key hash
      *
-     * @return {IdentifierWASM}
+     * @return {Promise<IdentifierWASM>}
      */
-    createVoterIdentityId(proTxHash: string, publicKeyHash: string): 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
        *

package/bundle.min.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */

package/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DashPlatformSDK = void 0;
-var DashPlatformSDK_1 = require("./src/DashPlatformSDK");
-Object.defineProperty(exports, "DashPlatformSDK", { enumerable: true, get: function () { return DashPlatformSDK_1.DashPlatformSDK; } });