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

package/src/identities/createStateTransition.js

@@ -0,0 +1,34 @@
+import { IdentityCreateTransitionWASM, IdentityTopUpTransitionWASM, IdentityUpdateTransitionWASM } from 'pshenmic-dpp';
+const identityTransitionsMap = {
+    create: {
+        class: IdentityCreateTransitionWASM,
+        arguments: ['publicKeys', 'assetLockProof'],
+        optionalArguments: ['signature', 'userFeeIncrease']
+    },
+    topUp: {
+        class: IdentityTopUpTransitionWASM,
+        arguments: ['assetLockProof', 'identityId'],
+        optionalArguments: ['userFeeIncrease']
+    },
+    update: {
+        class: IdentityUpdateTransitionWASM,
+        arguments: ['identityId', 'revision', 'identityNonce', 'addPublicKeys', 'disablePublicKeyIds'],
+        optionalArguments: ['userFeeIncrease']
+    }
+};
+export default function createStateTransition(type, params) {
+    const { class: TransitionClass, arguments: classArguments, optionalArguments } = identityTransitionsMap[type];
+    if (TransitionClass == null) {
+        throw new Error(`Unimplemented transition type: ${type}`);
+    }
+    const [missingArgument] = classArguments
+        .filter((classArgument) => params[classArgument] == null &&
+        !(optionalArguments).includes(classArgument));
+    if (missingArgument != null) {
+        throw new Error(`Token transition param "${missingArgument}" is missing`);
+    }
+    const transitionParams = classArguments.map((classArgument) => params[classArgument]);
+    // @ts-expect-error
+    const identityTransition = new TransitionClass(...transitionParams);
+    return identityTransition.toStateTransition();
+}

package/src/identities/getIdentityBalance.js

@@ -0,0 +1,40 @@
+import { GetIdentityBalanceRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityBalanceProof } from 'pshenmic-dpp';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+export default async function getIdentityBalance(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityBalanceRequest = GetIdentityBalanceRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                id: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityBalance(getIdentityBalanceRequest);
+    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, balance } = verifyIdentityBalanceProof(proof.grovedbProof, id.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    if (balance == null) {
+        throw new Error(`Failed to fetch balance for identifier ${id.base58()}`);
+    }
+    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 BigInt(balance);
+}

package/src/identities/getIdentityByIdentifier.js

@@ -0,0 +1,40 @@
+import { GetIdentityRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityByIdentifierProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getIdentityByIdentifier(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityRequest = GetIdentityRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                id: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentity(getIdentityRequest);
+    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, identity } = verifyIdentityByIdentifierProof(proof.grovedbProof, id, true, PlatformVersionWASM.PLATFORM_V9);
+    if (identity == null) {
+        throw new Error(`Identity with identifier ${id.base58()} 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 identity;
+}

package/src/identities/getIdentityByNonUniquePublicKeyHash.js

@@ -0,0 +1,44 @@
+import { GetIdentityByNonUniquePublicKeyHashRequest } from '../../proto/generated/platform';
+import { PlatformVersionWASM, verifyIdentifierByNonUniquePublicKeyHashProof } from 'pshenmic-dpp';
+import hexToBytes from '../utils/hexToBytes';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+import getIdentityByIdentifier from './getIdentityByIdentifier';
+export default async function getIdentityByNonUniquePublicKeyHash(grpcPool, hex) {
+    const getIdentityByNonUniquePublicKeyHashRequest = GetIdentityByNonUniquePublicKeyHashRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                publicKeyHash: hexToBytes(hex),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityByNonUniquePublicKeyHash(getIdentityByNonUniquePublicKeyHashRequest);
+    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');
+    }
+    if (proof.grovedbIdentityPublicKeyHashProof == null) {
+        throw new Error('GroveDB proof not found for identity by non unique public key request');
+    }
+    const { rootHash, identifier } = verifyIdentifierByNonUniquePublicKeyHashProof(proof.grovedbIdentityPublicKeyHashProof.grovedbProof, false, hexToBytes(hex), undefined, PlatformVersionWASM.PLATFORM_V9);
+    if (identifier == null) {
+        throw new Error(`Identity with non unique public key hash ${hex} not found`);
+    }
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.grovedbIdentityPublicKeyHashProof.quorumType, bytesToHex(proof.grovedbIdentityPublicKeyHashProof.quorumHash));
+    const verify = await verifyTenderdashProof(proof.grovedbIdentityPublicKeyHashProof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return await getIdentityByIdentifier(grpcPool, identifier);
+}

package/src/identities/getIdentityByPublicKeyHash.js

@@ -0,0 +1,40 @@
+import { GetIdentityByPublicKeyHashRequest } from '../../proto/generated/platform';
+import { PlatformVersionWASM, verifyIdentityByUniqueKeyHashProof } from 'pshenmic-dpp';
+import hexToBytes from '../utils/hexToBytes';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getIdentityByPublicKeyHash(grpcPool, hex) {
+    const getIdentityByPublicKeyHashRequest = GetIdentityByPublicKeyHashRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                publicKeyHash: hexToBytes(hex),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityByPublicKeyHash(getIdentityByPublicKeyHashRequest);
+    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, identity } = verifyIdentityByUniqueKeyHashProof(proof.grovedbProof, hexToBytes(hex), PlatformVersionWASM.PLATFORM_V9);
+    if (identity == null) {
+        throw new Error(`Identity with public key hash ${hex} 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 identity;
+}

package/src/identities/getIdentityContractNonce.js

@@ -0,0 +1,43 @@
+import { GetIdentityContractNonceRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityContractNonceProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
+export default async function getIdentityContractNonce(grpcPool, identity, dataContract) {
+    const identityIdentifier = new IdentifierWASM(identity);
+    const dataContractIdentifier = new IdentifierWASM(dataContract);
+    const getIdentityContractNonceRequest = GetIdentityContractNonceRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                identityId: identityIdentifier.bytes(),
+                contractId: dataContractIdentifier.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityContractNonce(getIdentityContractNonceRequest);
+    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, contractNonce } = verifyIdentityContractNonceProof(proof.grovedbProof, identityIdentifier.bytes(), dataContractIdentifier.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    if (contractNonce == null) {
+        return BigInt(0);
+    }
+    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 BigInt(contractNonce) & IDENTITY_CONTRACT_NONCE_VALUE_FILTER;
+}

package/src/identities/getIdentityNonce.js

@@ -0,0 +1,41 @@
+import { GetIdentityNonceRequest } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityNonceProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+const IDENTITY_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF);
+export default async function getIdentityNonce(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityNonceRequest = GetIdentityNonceRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                identityId: id.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityNonce(getIdentityNonceRequest);
+    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, nonce } = verifyIdentityNonceProof(proof.grovedbProof, id.bytes(), true, PlatformVersionWASM.PLATFORM_V9);
+    if (nonce == null) {
+        return BigInt(0);
+    }
+    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 BigInt(nonce) & IDENTITY_NONCE_VALUE_FILTER;
+}

package/src/identities/getIdentityPublicKeys.js

@@ -0,0 +1,47 @@
+import { GetIdentityKeysRequest, KeyRequestType } from '../../proto/generated/platform';
+import { IdentifierWASM, PlatformVersionWASM, verifyIdentityKeysByIdentifierProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey';
+import bytesToHex from '../utils/bytesToHex';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof';
+export default async function getIdentityPublicKeys(grpcPool, identifier) {
+    const id = new IdentifierWASM(identifier);
+    const getIdentityKeysRequest = GetIdentityKeysRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                identityId: id.bytes(),
+                requestType: KeyRequestType.create({
+                    request: {
+                        oneofKind: 'allKeys',
+                        allKeys: {}
+                    }
+                }),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getIdentityKeys(getIdentityKeysRequest);
+    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, identity } = verifyIdentityKeysByIdentifierProof(proof.grovedbProof, id.bytes(), null, false, false, true, null, null, PlatformVersionWASM.PLATFORM_V9);
+    if (identity == null) {
+        throw new Error(`Identity with identifier ${id.base58()} 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');
+    }
+    const loadedKeysIds = Object.keys(identity.loadedPublicKeys);
+    return loadedKeysIds.map((id) => identity.loadedPublicKeys[id]);
+}

package/src/identities/index.js

@@ -0,0 +1,141 @@
+import getIdentityContractNonce from './getIdentityContractNonce';
+import getIdentityPublicKeys from './getIdentityPublicKeys';
+import getIdentityNonce from './getIdentityNonce';
+import getIdentityBalance from './getIdentityBalance';
+import getIdentityByPublicKeyHash from './getIdentityByPublicKeyHash';
+import getIdentityByIdentifier from './getIdentityByIdentifier';
+import { AssetLockProofWASM, ContractBoundsWASM, IdentifierWASM, IdentityPublicKeyInCreationWASM, OutPointWASM } from 'pshenmic-dpp';
+import createStateTransition from './createStateTransition';
+import getIdentityByNonUniquePublicKeyHash from './getIdentityByNonUniquePublicKeyHash';
+import hexToBytes from '../utils/hexToBytes';
+/**
+ * Collection of methods to query identities and its related data
+ *
+ * @hideconstructor
+ */
+export class IdentitiesController {
+    /** @ignore */
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Get current balance of your Identity by identifier
+     *
+     * @param identifier {IdentifierLike} Identifier of an identity
+     *
+     * @return {Promise<bigint>}
+     */
+    async getIdentityBalance(identifier) {
+        return await getIdentityBalance(this.grpcPool, identifier);
+    }
+    /**
+     * Retrieves an Identity from the network by give public key hash
+     *
+     * @param hex {string} public key hash value in hex, should be a length of 40
+     *
+     * @return {Promise<IdentityWASM>}
+     */
+    async getIdentityByPublicKeyHash(hex) {
+        if (hex.length !== 40) {
+            throw new Error('Public key hash should equal 40');
+        }
+        return await getIdentityByPublicKeyHash(this.grpcPool, hex);
+    }
+    /**
+     * Retrieves an Identity from the network by non-unique public key hash (like Voter Identity, SHA160)
+     *
+     * @param hex {string} public key hash value in hex, should be a length of 40
+     *
+     * @return {Promise<IdentityWASM>}
+     */
+    async getIdentityByNonUniquePublicKeyHash(hex) {
+        if (hex.length !== 40) {
+            throw new Error('Public key hash should equal 40');
+        }
+        return await getIdentityByNonUniquePublicKeyHash(this.grpcPool, hex);
+    }
+    /**
+     * Retrieves Identity by identifier from the network
+     * @param identifier {IdentifierLike} identifier
+     *
+     * @return {Promise<IdentityWASM>}
+     */
+    async getIdentityByIdentifier(identifier) {
+        return await getIdentityByIdentifier(this.grpcPool, identifier);
+    }
+    /**
+     * Get Identity Nonce (usually used by Identity transitions)
+     * @param identifier
+     */
+    async getIdentityNonce(identifier) {
+        return await getIdentityNonce(this.grpcPool, identifier);
+    }
+    /**
+     * Get Identity Contract Nonce (usually used by Document transitions)
+     * @param identifier
+     * @param dataContract
+     *
+     * @return {Promise<bigint>}
+     */
+    async getIdentityContractNonce(identifier, dataContract) {
+        return await getIdentityContractNonce(this.grpcPool, identifier, dataContract);
+    }
+    /**
+     * Retrieve given Identity's public keys
+     * @param identifier
+     *
+     * @return {Promise<IdentityPublicKeyWASM[]>}
+     */
+    async getIdentityPublicKeys(identifier) {
+        return await getIdentityPublicKeys(this.grpcPool, identifier);
+    }
+    /**
+     * Helper function for creating {StateTransitionWASM} for Identity transitions
+     *
+     * To create an IdentityCreateTransition, you should pass a params.assetLockProof object containing
+     * all necessary AssetLockProof data to make the transaction.
+     * Both InstantSend and ChainLock AssetLock proofs supported
+     *
+     * @param type {string} type of transition, must be a one of ('create' | 'update' | 'topUp')
+     * @param params {IdentityTransitionParams} params
+     */
+    createStateTransition(type, params) {
+        if (params.identityId != null) {
+            params.identityId = new IdentifierWASM(params.identityId);
+        }
+        if (params.disablePublicKeyIds == null) {
+            params.disablePublicKeyIds = [];
+        }
+        if (params.assetLockProof != null) {
+            const { type } = params.assetLockProof;
+            if (type === 'chainLock') {
+                const { txid, outputIndex, coreChainLockedHeight } = params.assetLockProof;
+                // @ts-expect-error
+                params.assetLockProof = AssetLockProofWASM.createChainAssetLockProof(coreChainLockedHeight, new OutPointWASM(txid, outputIndex));
+            }
+            else if (type === 'instantLock') {
+                const { transaction, outputIndex, instantLock } = params.assetLockProof;
+                // @ts-expect-error
+                params.assetLockProof = AssetLockProofWASM.createInstantAssetLockProof(hexToBytes(instantLock), hexToBytes(transaction), outputIndex);
+            }
+            else if (type == null) {
+                throw new Error('Missing Asset Lock type in the params');
+            }
+            else {
+                throw new Error(`Unknown Asset Lock type: ${type}`);
+            }
+        }
+        if (params.addPublicKeys != null) {
+            // @ts-expect-error
+            params.addPublicKeys = params.addPublicKeys
+                .map(({ id, purpose, securityLevel, keyType, readOnly, data, signature, contractBounds }) => new IdentityPublicKeyInCreationWASM(id, purpose, securityLevel, keyType, readOnly, data, signature, (contractBounds != null) ? new ContractBoundsWASM(contractBounds.dataContractId, contractBounds.documentType) : undefined));
+        }
+        if (params.publicKeys != null) {
+            // @ts-expect-error
+            params.publicKeys = params.publicKeys
+                .map(({ id, purpose, securityLevel, keyType, readOnly, data, signature, contractBounds }) => new IdentityPublicKeyInCreationWASM(id, purpose, securityLevel, keyType, readOnly, data, signature, (contractBounds != null) ? new ContractBoundsWASM(contractBounds.dataContractId, contractBounds.documentType) : undefined));
+        }
+        return createStateTransition(type, params);
+    }
+}

package/src/keyPair/deriveChild.js

@@ -0,0 +1,3 @@
+export default function deriveChild(hdKey, index) {
+    return hdKey.deriveChild(index);
+}

package/src/keyPair/derivePath.js

@@ -0,0 +1,3 @@
+export default function derivePath(hdKey, path) {
+    return hdKey.derive(path);
+}

package/src/keyPair/index.js

@@ -0,0 +1,89 @@
+import { HDKey } from '@scure/bip32';
+import mnemonicToSeed from './mnemonicToSeed';
+import deriveChild from './deriveChild';
+import derivePath from './derivePath';
+import { p2pkh } from '@scure/btc-signer';
+const DASH_VERSIONS = {
+    mainnet: { pubKeyHash: 0x4c, scriptHash: 0x10, bech32: 'dc', wif: 0xcc, private: 0x0488ade4, public: 0x0488b21e },
+    testnet: { pubKeyHash: 0x8c, scriptHash: 0x13, bech32: 'dc', wif: 0xef, private: 0x04358394, public: 0x043587cf }
+};
+/**
+ * Collection of functions to work with private keys and seed phrases
+ *
+ * @hideconstructor
+ */
+export class KeyPairController {
+    /**
+     * Returns seed from mnemonic phrase
+     *
+     * @param mnemonic {string} - The BIP39 mnemonic phrase.
+     * @param salt {string=} -  Optional salt for seed derivation.
+     *
+     * @return {Uint8Array} Seed bytes
+     */
+    mnemonicToSeed(mnemonic, salt) {
+        return mnemonicToSeed(mnemonic, salt);
+    }
+    /**
+     * Returns seed from mnemonic phrase
+     *
+     * @param seed {Uint8Array}
+     * @param network {Network} network
+     *
+     * @return {HDKey} HDKey
+     */
+    seedToHdKey(seed, network = 'mainnet') {
+        return HDKey.fromMasterSeed(seed, DASH_VERSIONS[network]);
+    }
+    /**
+       * 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
+       */
+    async deriveChild(hdKey, index) {
+        return deriveChild(hdKey, index);
+    }
+    /**
+       * 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
+       */
+    async derivePath(hdKey, path) {
+        return derivePath(hdKey, path);
+    }
+    /**
+     * Derives an {HDKey} child by identity index and key index from an {HDKey}
+     *
+     * Usually used to get a identity private key from seed
+     *
+     * @param hdKey {HDKey}
+     * @param identityIndex {number}
+     * @param keyIndex {number}
+     * @param network {Network}
+     *
+     * @returns {HDKey}
+     */
+    deriveIdentityPrivateKey(hdKey, identityIndex, keyIndex, network) {
+        const networkIndex = network === 'mainnet' ? 5 : 1;
+        const pathPostfix = `/5'/0'/0'/${identityIndex}'/${keyIndex}'`;
+        return derivePath(hdKey, `m/9'/${networkIndex}'${pathPostfix}`);
+    }
+    /**
+     * Converts {PublicKey} to a Dash network address (P2PKH)
+     *
+     * @param publicKey {Uint8Array}
+     * @param network {Network}
+     *
+     * @returns {string}
+     */
+    p2pkhAddress(publicKey, network) {
+        const P2PKH = p2pkh(publicKey, DASH_VERSIONS[network]);
+        return P2PKH.address;
+    }
+}

package/src/keyPair/mnemonicToSeed.js

@@ -0,0 +1,4 @@
+import { mnemonicToSeedSync as func } from '@scure/bip39';
+export default function mnemonicToSeed(mnemonic, salt) {
+    return func(mnemonic, salt);
+}