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

package/src/identities/index.js

@@ -0,0 +1,141 @@
+import getIdentityContractNonce from './getIdentityContractNonce.js';
+import getIdentityPublicKeys from './getIdentityPublicKeys.js';
+import getIdentityNonce from './getIdentityNonce.js';
+import getIdentityBalance from './getIdentityBalance.js';
+import getIdentityByPublicKeyHash from './getIdentityByPublicKeyHash.js';
+import getIdentityByIdentifier from './getIdentityByIdentifier.js';
+import { AssetLockProofWASM, ContractBoundsWASM, IdentifierWASM, IdentityPublicKeyInCreationWASM, OutPointWASM } from 'pshenmic-dpp';
+import createStateTransition from './createStateTransition.js';
+import getIdentityByNonUniquePublicKeyHash from './getIdentityByNonUniquePublicKeyHash.js';
+import hexToBytes from '../utils/hexToBytes.js';
+/**
+ * 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.d.ts

@@ -1,5 +1,5 @@
 import { HDKey } from '@scure/bip32';
-import { Network } from '../types';
+import { Network } from '../types.js';
 /**
  * Collection of functions to work with private keys and seed phrases
  *

package/src/keyPair/index.js

@@ -0,0 +1,89 @@
+import { HDKey } from '@scure/bip32';
+import mnemonicToSeed from './mnemonicToSeed.js';
+import deriveChild from './deriveChild.js';
+import derivePath from './derivePath.js';
+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);
+}

package/src/names/index.d.ts

@@ -1,6 +1,6 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 import { DocumentWASM, PrivateKeyWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../types';
+import { IdentifierLike } from '../types.js';
 /**
  * Functions related to DPNS names (usernames)
  *

package/src/names/index.js

@@ -0,0 +1,102 @@
+import { IdentifierWASM } from 'pshenmic-dpp';
+import searchByName from './searchByName.js';
+import searchByIdentity from './searchByIdentity.js';
+import registerName from './registerName.js';
+import validateName from './validateName.js';
+import getIdentityByIdentifier from '../identities/getIdentityByIdentifier.js';
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars.js';
+import testNameContested from './testNameContested.js';
+/**
+ * Functions related to DPNS names (usernames)
+ *
+ * @hideconstructor
+ */
+export class NamesController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Searches for a registered DPNS name in the network
+     *
+     * Should be in a human-readable format, for example pshenmic.dash
+     *
+     * Returns a {DocumentWASM} document of type 'domain' from DPNS system data contract if found,
+     * returns null if not found.
+     *
+     * https://testnet.platform-explorer.com/dataContract/GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec?tab=schema
+     *
+     * @param name {string}
+     *
+     * @return Promise<DocumentWASM | null>
+     */
+    async searchByName(name) {
+        const validation = validateName(name);
+        if (validation != null) {
+            throw new Error(validation);
+        }
+        return await searchByName(this.grpcPool, name);
+    }
+    /**
+     * Tests a given username against contested names rules.
+     * Contested names includes an additional fee of 0.2 Dash
+     * as a voting resolution fee
+     *
+     * This function return boolean whether given username (f.e pshenmic.dash)
+     * falls under contested names rules.
+     * @param name
+     */
+    testNameContested(name) {
+        const validation = validateName(name);
+        if (validation != null) {
+            throw new Error(validation);
+        }
+        const [label] = name.split('.');
+        const normalizedLabel = convertToHomographSafeChars(label);
+        return testNameContested(normalizedLabel);
+    }
+    async searchByIdentity(identifier) {
+        return await searchByIdentity(this.grpcPool, new IdentifierWASM(identifier));
+    }
+    /**
+     * Performs a DPNS name registration sequence
+     * Contested names are include additional fee of 0.2 Dash
+     * Check your name is contested with .testNameContested(name) method to check if additional fee will be charged
+     *
+     * @param name {string} username (ex. pshenmic.dash)
+     * @param identityId {IdentifierLike} identity identifier
+     * @param privateKey {PrivateKeyWASM} Authentication / High private key from your identity
+     */
+    async registerName(name, identityId, privateKey) {
+        const validation = validateName(name);
+        if (validation != null) {
+            throw new Error(validation);
+        }
+        const identity = await getIdentityByIdentifier(this.grpcPool, identityId);
+        await registerName(this.grpcPool, name, identity, privateKey);
+    }
+    /**
+     * Converts DPNS name to normalized format (ex. alice.dash -> al1ce.dash)
+     *
+     * source: https://github.com/dashpay/platform/blob/master/packages/js-dash-sdk/src/utils/convertToHomographSafeChars.ts
+     *
+     *
+     * @param label {string}
+     *
+     * @return {string}
+     */
+    normalizeLabel(label) {
+        return convertToHomographSafeChars(label);
+    }
+    /**
+     * Validates a DPNS name that you would like to register
+     *
+     * @param fullName {string} full DPNS name (ex. pshenmic.dash)
+     *
+     * @return {string} null if valid or string with a reason
+     */
+    validateName(fullName) {
+        return validateName(fullName);
+    }
+}

package/src/names/registerName.d.ts

@@ -1,3 +1,3 @@
 import { IdentityWASM, PrivateKeyWASM } from 'pshenmic-dpp';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function registerName(grpcPool: GRPCConnectionPool, name: string, identity: IdentityWASM, privateKey: PrivateKeyWASM): Promise<void>;

package/src/names/registerName.js

@@ -0,0 +1,64 @@
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars.js';
+import { PrefundedVotingBalanceWASM } from 'pshenmic-dpp';
+import getRandomBytes from '../utils/getRandomBytes.js';
+import sha256 from '../utils/sha256.js';
+import createDocument from '../documents/create.js';
+import createStateTransition from '../documents/createStateTransition.js';
+import getIdentityContractNonce from '../identities/getIdentityContractNonce.js';
+import broadcast from '../stateTransitions/broadcast.js';
+import waitForStateTransitionResult from '../stateTransitions/waitForStateTransitionResult.js';
+import testNameContested from './testNameContested.js';
+import { DPNS_DATA_CONTRACT_ID } from '../constants.js';
+export default async function registerName(grpcPool, name, identity, privateKey) {
+    const [identityPublicKey] = identity.getPublicKeys().filter(identityPublicKey => identityPublicKey.getPublicKeyHash() === privateKey.getPublicKeyHash());
+    if (identityPublicKey == null) {
+        throw new Error('Private key does not match the identity');
+    }
+    if (identityPublicKey.securityLevel !== 'HIGH' && identityPublicKey.purpose !== 'AUTHENTICATION') {
+        throw new Error('Wrong private key, must be from AUTHENTICATION HIGH identity public key');
+    }
+    const [label, parentDomainName] = name.split('.');
+    const salt = getRandomBytes(32);
+    const normalizedParentDomainName = convertToHomographSafeChars(parentDomainName);
+    const normalizedLabel = convertToHomographSafeChars(label);
+    const normalizedFullDomainName = `${normalizedLabel}.${normalizedParentDomainName}`;
+    const saltedDomainHash = await sha256(await sha256(new Uint8Array([
+        ...salt,
+        ...new TextEncoder().encode(normalizedFullDomainName)
+    ])));
+    let document;
+    let stateTransition;
+    // 1. Create preorder document
+    const preorderData = {
+        saltedDomainHash: Array.from(saltedDomainHash)
+    };
+    const identityContractNonce = await getIdentityContractNonce(grpcPool, identity.id, DPNS_DATA_CONTRACT_ID);
+    document = createDocument(DPNS_DATA_CONTRACT_ID, 'preorder', preorderData, identity.id.base58());
+    stateTransition = createStateTransition(document, 'create', { identityContractNonce: identityContractNonce + BigInt(1) });
+    await stateTransition.sign(privateKey, identityPublicKey);
+    await broadcast(grpcPool, stateTransition);
+    // wait for state transition confirmation before next broadcast
+    await waitForStateTransitionResult(grpcPool, stateTransition);
+    // 2. Create domain document
+    const domainData = {
+        label,
+        normalizedLabel,
+        parentDomainName,
+        normalizedParentDomainName,
+        preorderSalt: Array.from(salt),
+        records: {
+            identity: Array.from(identity.id.bytes())
+        },
+        subdomainRules: {
+            allowSubdomains: false
+        }
+    };
+    document = createDocument(DPNS_DATA_CONTRACT_ID, 'domain', domainData, identity.id.base58());
+    stateTransition = createStateTransition(document, 'create', {
+        identityContractNonce: identityContractNonce + BigInt(2),
+        // @ts-expect-error
+        prefundedVotingBalance: testNameContested(normalizedLabel) ? new PrefundedVotingBalanceWASM('parentNameAndLabel', BigInt(20000000000)) : undefined
+    });
+    await stateTransition.sign(privateKey, identityPublicKey);
+    await broadcast(grpcPool, stateTransition);
+}

package/src/names/searchByIdentity.d.ts

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

package/src/names/searchByIdentity.js

@@ -0,0 +1,5 @@
+import query from '../documents/query.js';
+const DPNS_DATA_CONTRACT_ID = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+export default async function searchByIdentity(grpcPool, identifier) {
+    return await query(grpcPool, DPNS_DATA_CONTRACT_ID, 'domain', [['records.identity', '=', identifier.base58()]], [['records.identity', 'asc']]);
+}

package/src/names/searchByName.d.ts

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

package/src/names/searchByName.js

@@ -0,0 +1,16 @@
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars.js';
+import query from '../documents/query.js';
+const DPNS_DATA_CONTRACT_ID = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
+export default async function search(grpcPool, name) {
+    const [label, parentDomainName] = name.split('.');
+    const normalizedParentDomainName = convertToHomographSafeChars(parentDomainName);
+    const normalizedLabelPrefix = convertToHomographSafeChars(label);
+    const where = [
+        ['normalizedParentDomainName', '==', normalizedParentDomainName],
+        ['normalizedLabel', 'startsWith', normalizedLabelPrefix]
+    ];
+    const orderBy = [
+        ['normalizedLabel', 'asc']
+    ];
+    return await query(grpcPool, DPNS_DATA_CONTRACT_ID, 'domain', where, orderBy);
+}

package/src/names/testNameContested.js

@@ -0,0 +1,3 @@
+export default function testNameContested(normalizedLabel) {
+    return /^[a-zA-Z01-]{3,19}$/.test(normalizedLabel);
+}

package/src/names/validateName.js

@@ -0,0 +1,11 @@
+export default function validateName(fullName) {
+    const chunks = fullName.split('.');
+    if (chunks.length !== 2) {
+        return 'Name to search should be a full domain name (ex. pshenmic.dash)';
+    }
+    const [label, parentDomainName] = chunks;
+    if (parentDomainName !== 'dash') {
+        return 'Root domain must be .dash';
+    }
+    return /^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]$/.test(label) ? null : 'Unacceptable label name';
+}

package/src/node/epochs.d.ts

@@ -1,4 +1,4 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export interface EpochInfo {
     number: number;
     firstBlockHeight: number;

package/src/node/epochs.js

@@ -0,0 +1,46 @@
+import { GetEpochsInfoRequest } from '../../proto/generated/platform.js';
+import { PlatformVersionWASM, verifyEpochsInfoProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { UInt32Value } from '../../proto/generated/google/protobuf/wrappers.js';
+export default async function epochs(grpcPool, count, ascending, start) {
+    const getEpochsInfoRequest = GetEpochsInfoRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                startEpoch: start != null ? UInt32Value.create({ value: start }) : undefined,
+                count,
+                ascending,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getEpochsInfo(getEpochsInfoRequest);
+    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, epochsInfo } = verifyEpochsInfoProof(proof.grovedbProof, metadata.epoch, start, count, ascending, 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 epochsInfo.map(info => ({
+        number: info.index,
+        firstBlockHeight: info.firstBlockHeight,
+        firstCoreBlockHeight: info.firstCoreBlockHeight,
+        startTime: info.firstBlockTime,
+        feeMultiplier: info.feeMultiplierPermille,
+        protocolVersion: info.protocolVersion
+    }));
+}

package/src/node/index.d.ts

@@ -1,6 +1,6 @@
-import GRPCConnectionPool from '../grpcConnectionPool';
-import { Network, NodeStatus } from '../types';
-import { EpochInfo } from './epochs';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { Network, NodeStatus } from '../types.js';
+import { EpochInfo } from './epochs.js';
 /**
  * Node controller for requesting information about DAPI node
  *

package/src/node/index.js

@@ -0,0 +1,43 @@
+import getStatus from './status.js';
+import getEpochsInfo from './epochs.js';
+import getTotalCredits from './totalCredits.js';
+/**
+ * Node controller for requesting information about DAPI node
+ *
+ * @hideconstructor
+ */
+export class NodeController {
+    /** @ignore **/
+    grpcPool;
+    network;
+    constructor(grpcPool, network) {
+        this.grpcPool = grpcPool;
+        this.network = network;
+    }
+    /**
+     * Retrieves an info about node
+     * Includes information about genesis, chain, software versions
+     *
+     * @return {Promise<NodeStatus>}
+     */
+    async status() {
+        return await getStatus(this.grpcPool);
+    }
+    /**
+     * Returns total credits amount in platform
+     *
+     * @return {Promise<bigint>}
+     */
+    async totalCredits() {
+        return await getTotalCredits(this.grpcPool, this.network);
+    }
+    /**
+     * Retrieves an info about epochs
+     * Includes information about first block height, time, fee multiplier, number
+     *
+     * @return {Promise<EpochInfo[]>}
+     */
+    async getEpochsInfo(count, ascending, start) {
+        return await getEpochsInfo(this.grpcPool, count, ascending, start);
+    }
+}

package/src/node/status.d.ts

@@ -1,3 +1,3 @@
-import { NodeStatus } from '../types';
-import GRPCConnectionPool from '../grpcConnectionPool';
+import { NodeStatus } from '../types.js';
+import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function status(grpcPool: GRPCConnectionPool): Promise<NodeStatus>;

package/src/node/status.js

@@ -0,0 +1,41 @@
+import { GetStatusRequest } from '../../proto/generated/platform.js';
+import bytesToHex from '../utils/bytesToHex.js';
+export default async function status(grpcPool) {
+    const getStatusRequest = GetStatusRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {}
+        }
+    });
+    const { response } = await grpcPool.getClient().getStatus(getStatusRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    return {
+        node: (v0.node != null)
+            ? {
+                id: bytesToHex(v0.node.id),
+                proTxHash: v0.node.proTxHash != null ? bytesToHex(v0.node.proTxHash) : undefined
+            }
+            : undefined,
+        chain: (v0.chain != null)
+            ? {
+                catchingUp: v0.chain.catchingUp,
+                latestBlockHeight: v0.chain.latestBlockHeight,
+                earliestBlockHeight: v0.chain.earliestBlockHeight,
+                maxPeerBlockHeight: v0.chain.maxPeerBlockHeight,
+                coreChainLockedHeight: v0.chain.coreChainLockedHeight,
+                latestBlockHash: v0.chain?.latestBlockHash != null ? bytesToHex(v0.chain?.latestBlockHash) : '',
+                latestAppHash: v0.chain?.latestAppHash != null ? bytesToHex(v0.chain?.latestAppHash) : '',
+                earliestBlockHash: v0.chain?.earliestBlockHash != null ? bytesToHex(v0.chain?.earliestBlockHash) : '',
+                earliestAppHash: v0.chain?.earliestAppHash != null ? bytesToHex(v0.chain?.earliestAppHash) : ''
+            }
+            : undefined,
+        version: v0.version,
+        network: v0.network,
+        stateSync: v0.stateSync,
+        time: v0.time
+    };
+}

package/src/node/totalCredits.d.ts

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