dash-platform-sdk 1.4.0-dev.1 → 1.4.0-dev.11

package/src/DashPlatformSDK.js

@@ -10,6 +10,7 @@ import { DataContractsController } from './dataContracts/index.js';
 import { ContestedResourcesController } from './contestedResources/index.js';
 import { TokensController } from './tokens/index.js';
 import { VotingController } from './voting/index.js';
+import { PlatformAddressesController } from './platformAddresses/index.js';
 /**
  * Javascript SDK for that let you interact with a Dash Platform blockchain
  */
@@ -20,6 +21,7 @@ export class DashPlatformSDK {
     /** @ignore **/
     options;
     contestedResources;
+    platformAddresses;
     stateTransitions;
     dataContracts;
     identities;
@@ -49,7 +51,7 @@ export class DashPlatformSDK {
             this.options.grpc = { dapiUrl: options.dapiUrl };
         }
         this.grpcPool = new GRPCConnectionPool(this.network, this.options?.grpc);
-        this._initialize(this.grpcPool, this.network);
+        this._initialize(this.grpcPool);
     }
     /**
      * @private
@@ -59,15 +61,16 @@ export class DashPlatformSDK {
      * @param grpcPool
      * @param network
      */
-    _initialize(grpcPool, network) {
+    _initialize(grpcPool) {
         this.grpcPool = grpcPool;
-        this.stateTransitions = new StateTransitionsController(grpcPool);
         this.contestedResources = new ContestedResourcesController(grpcPool);
+        this.platformAddresses = new PlatformAddressesController(grpcPool);
+        this.stateTransitions = new StateTransitionsController(grpcPool);
         this.dataContracts = new DataContractsController(grpcPool);
         this.identities = new IdentitiesController(grpcPool);
         this.documents = new DocumentsController(grpcPool);
         this.voting = new VotingController();
-        this.node = new NodeController(grpcPool, network);
+        this.node = new NodeController(grpcPool);
         this.tokens = new TokensController(grpcPool);
         this.names = new NamesController(grpcPool);
         this.keyPair = new KeyPairController();
@@ -91,6 +94,6 @@ export class DashPlatformSDK {
         }
         this.network = network;
         const grpcPool = new GRPCConnectionPool(this.network, this.options?.grpc);
-        this._initialize(grpcPool, this.network);
+        this._initialize(grpcPool);
     }
 }

package/src/contestedResources/getContestedResourceVoteState.js

@@ -66,7 +66,7 @@ export default async function getContestedResourceVoteState(grpcPool, contract,
         finishedVoteInfo: (winner != null)
             ? {
                 type: winner.type,
-                wonByIdentityId: 'identityId' in winner ? new IdentifierWASM(winner.identityId) : undefined,
+                wonByIdentityId: 'identityId' in winner && winner.identityId != null ? new IdentifierWASM(winner.identityId) : undefined,
                 finishedAtBlockHeight: winner.blockInfo.height,
                 finishedAtCoreBlockHeight: winner.blockInfo.coreHeight,
                 finishedAtBlockTimeMs: winner.blockInfo.timeMs,

package/src/dataContracts/create.d.ts

@@ -1,3 +1,3 @@
-import { DataContractTokens, DataContractWASM, PlatformVersionWASM } from 'pshenmic-dpp';
-import { DataContractConfig, IdentifierLike } from '../../types.js';
+import { DataContractTokens, DataContractWASM, IdentifierLike, PlatformVersionWASM } from 'pshenmic-dpp';
+import { DataContractConfig } from '../../types.js';
 export default function createDataContract(ownerId: IdentifierLike, identityNonce: bigint, schema: object, tokenConfiguration?: DataContractTokens[], config?: DataContractConfig, fullValidation?: boolean | undefined, platformVersion?: PlatformVersionWASM | undefined): DataContractWASM;

package/src/dataContracts/getDataContractByIdentifier.d.ts

@@ -1,4 +1,3 @@
-import { DataContractWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { DataContractWASM, IdentifierLike } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getByIdentifier(grpcPool: GRPCConnectionPool, identifier: IdentifierLike): Promise<DataContractWASM>;

package/src/dataContracts/index.d.ts

@@ -1,6 +1,6 @@
-import { DataContractConfig, IdentifierLike } from '../../types.js';
-import { DataContractTokens, DataContractWASM, PlatformVersionWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DataContractTokens, DataContractWASM, IdentifierLike, PlatformVersionWASM, StateTransitionWASM } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { DataContractConfig } from '../../types.js';
 /**
  * Collection of methods necessary to work with Data Contracts in the network,
  * such as data contract creation or retrieval

package/src/documents/create.d.ts

@@ -1,3 +1,2 @@
-import { DocumentWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { DocumentWASM, IdentifierLike } from 'pshenmic-dpp';
 export default function createDocument(dataContractId: IdentifierLike, documentType: string, data: object, owner: IdentifierLike, revision?: bigint, documentId?: IdentifierLike): DocumentWASM;

package/src/documents/index.d.ts

@@ -1,5 +1,5 @@
-import { DocumentTransitionParams, IdentifierLike } from '../../types.js';
-import { DocumentWASM, IdentifierWASM, StateTransitionWASM, WhereClause } from 'pshenmic-dpp';
+import { DocumentTransitionParams } from '../../types.js';
+import { DocumentWASM, IdentifierLike, IdentifierWASM, StateTransitionWASM, WhereClause } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 /**
  * Collection of methods to work with documents like creation, querying or preparing a transition action

package/src/documents/index.js

@@ -39,7 +39,7 @@ export class DocumentsController {
      * @param startAfter {IdentifierLike=} Same as previous, but with exclusion. Cannot be set if startAt already provided
      */
     async query(dataContractId, documentType, where, orderBy, limit, startAt, startAfter) {
-        if (startAfter != null && startAt !== null) {
+        if (startAfter != null && startAt != null) {
             throw new Error('You may only set either startAfter or startAt at once');
         }
         return await query(this.grpcPool, new IdentifierWASM(dataContractId), documentType, where, orderBy, limit ?? 100, startAt, startAfter);

package/src/documents/query.d.ts

@@ -1,4 +1,3 @@
-import { DocumentWASM, IdentifierWASM, WhereClause } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { DocumentWASM, IdentifierLike, IdentifierWASM, WhereClause } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function query(grpcPool: GRPCConnectionPool, dataContractId: IdentifierLike, documentTypeName: string, where?: WhereClause[], orderBy?: string[][], limit?: number | undefined, startAt?: IdentifierWASM, startAfter?: IdentifierWASM): Promise<DocumentWASM[]>;

package/src/documents/query.js

@@ -7,20 +7,17 @@ import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
 import { encode } from 'cbor-x';
 import getDataContractByIdentifier from '../dataContracts/getDataContractByIdentifier.js';
 export default async function query(grpcPool, dataContractId, documentTypeName, where, orderBy, limit = 100, startAt, startAfter) {
-    if ([startAt, startAfter].filter(e => e != null).length === 2) {
-        throw new Error('Only startAt or startAfter could be specified at one time');
-    }
     let start;
     if (startAt != null) {
         start = {
             oneofKind: 'startAt',
-            startAt: startAt.base58()
+            startAt: startAt.bytes()
         };
     }
     if (startAfter != null) {
         start = {
             oneofKind: 'startAfter',
-            startAt: startAfter.base58()
+            startAfter: startAfter.bytes()
         };
     }
     const getDocumentsRequest = GetDocumentsRequest.create({
@@ -52,7 +49,8 @@ export default async function query(grpcPool, dataContractId, documentTypeName,
         throw new Error('Metadata not found');
     }
     const startAtIncluded = startAt != null;
-    const { rootHash, documents } = verifyDocumentsProof(proof.grovedbProof, dataContract, documentTypeName, where, orderBy, limit, startAt?.bytes(), startAtIncluded, BigInt(metadata?.timeMs), LATEST_PLATFORM_VERSION);
+    const startIdentifier = startAt ?? startAfter;
+    const { rootHash, documents } = verifyDocumentsProof(proof.grovedbProof, dataContract, documentTypeName, where, orderBy, limit, startIdentifier?.bytes(), startAtIncluded, BigInt(metadata?.timeMs), LATEST_PLATFORM_VERSION);
     const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
     const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
     if (!verify) {

package/src/identities/getIdentityBalance.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../../types.js';
+import { IdentifierLike } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityBalance(grpcPool: GRPCConnectionPool, identifier: IdentifierLike): Promise<bigint>;

package/src/identities/getIdentityByIdentifier.d.ts

@@ -1,4 +1,3 @@
-import { IdentityWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { IdentifierLike, IdentityWASM } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityByIdentifier(grpcPool: GRPCConnectionPool, identifier: IdentifierLike): Promise<IdentityWASM>;

package/src/identities/getIdentityContractNonce.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../../types.js';
+import { IdentifierLike } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityContractNonce(grpcPool: GRPCConnectionPool, identity: IdentifierLike, dataContract: IdentifierLike): Promise<bigint>;

package/src/identities/getIdentityNonce.d.ts

@@ -1,3 +1,3 @@
-import { IdentifierLike } from '../../types.js';
+import { IdentifierLike } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityNonce(grpcPool: GRPCConnectionPool, identifier: IdentifierLike): Promise<bigint>;

package/src/identities/getIdentityPublicKeys.d.ts

@@ -1,4 +1,3 @@
-import { IdentityPublicKeyWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { IdentifierLike, IdentityPublicKeyWASM } from 'pshenmic-dpp';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 export default function getIdentityPublicKeys(grpcPool: GRPCConnectionPool, identifier: IdentifierLike, keyIds?: number[]): Promise<IdentityPublicKeyWASM[]>;

package/src/identities/index.d.ts

@@ -1,6 +1,6 @@
-import { IdentifierLike, IdentityTransitionParams } from '../../types.js';
+import { IdentityTransitionParams } from '../../types.js';
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentityPublicKeyWASM, IdentityWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { IdentifierLike, IdentityPublicKeyWASM, IdentityWASM, StateTransitionWASM } from 'pshenmic-dpp';
 /**
  * Collection of methods to query identities and its related data
  *

package/src/names/index.d.ts

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

package/src/node/index.d.ts

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

package/src/node/index.js

@@ -9,10 +9,8 @@ import getTotalCredits from './totalCredits.js';
 export class NodeController {
     /** @ignore **/
     grpcPool;
-    network;
-    constructor(grpcPool, network) {
+    constructor(grpcPool) {
         this.grpcPool = grpcPool;
-        this.network = network;
     }
     /**
      * Retrieves an info about node
@@ -29,7 +27,7 @@ export class NodeController {
      * @return {Promise<bigint>}
      */
     async totalCredits() {
-        return await getTotalCredits(this.grpcPool, this.network);
+        return await getTotalCredits(this.grpcPool);
     }
     /**
      * Retrieves an info about epochs

package/src/node/totalCredits.d.ts

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

package/src/node/totalCredits.js

@@ -4,7 +4,7 @@ import { verifyTotalCreditsProof } from 'pshenmic-dpp';
 import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
 import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
-export default async function totalCredits(grpcPool, network) {
+export default async function totalCredits(grpcPool) {
     const getTotalCreditsInPlatformRequest = GetTotalCreditsInPlatformRequest.create({
         version: {
             oneofKind: 'v0',
@@ -24,7 +24,7 @@ export default async function totalCredits(grpcPool, network) {
     if (metadata == null) {
         throw new Error('Metadata not found');
     }
-    const activationHeight = network === 'testnet' ? TESTNET_ACTIVATION_HEIGHT : MAINNET_ACTIVATION_HEIGHT;
+    const activationHeight = grpcPool.network === 'testnet' ? TESTNET_ACTIVATION_HEIGHT : MAINNET_ACTIVATION_HEIGHT;
     const { rootHash, totalCredits } = verifyTotalCreditsProof(proof.grovedbProof, HALVING_INTERVAL, activationHeight, Number(metadata.height), LATEST_PLATFORM_VERSION);
     const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
     const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);

package/src/platformAddresses/getAddressInfo.d.ts

@@ -0,0 +1,4 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { PlatformAddressLike } from 'pshenmic-dpp';
+import { PlatformAddressInfo } from '../../types.js';
+export declare function getAddressInfo(grpcPool: GRPCConnectionPool, platformAddress: PlatformAddressLike): Promise<PlatformAddressInfo>;

package/src/platformAddresses/getAddressInfo.js

@@ -0,0 +1,45 @@
+import { PlatformAddressWASM, verifyPlatformAddressInfo } from 'pshenmic-dpp';
+import { GetAddressInfoRequest } from '../../proto/generated/platform.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+export async function getAddressInfo(grpcPool, platformAddress) {
+    const platformAddressWASM = new PlatformAddressWASM(platformAddress);
+    const getAddressInfoRequest = GetAddressInfoRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                address: platformAddressWASM.bytes(),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getAddressInfo(getAddressInfoRequest);
+    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, address, nonce, balance } = verifyPlatformAddressInfo(proof.grovedbProof, platformAddressWASM, true, LATEST_PLATFORM_VERSION);
+    if (address == null || nonce == null || balance == null) {
+        throw new Error(`Failed to fetch info for address ${platformAddressWASM.toBech32m(grpcPool.network)}`);
+    }
+    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 {
+        address,
+        nonce,
+        balance
+    };
+}

package/src/platformAddresses/getAddressesInfos.d.ts

@@ -0,0 +1,4 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { PlatformAddressLike } from 'pshenmic-dpp';
+import { PlatformAddressInfo } from '../../types.js';
+export declare function getAddressesInfos(grpcPool: GRPCConnectionPool, platformAddresses: PlatformAddressLike[]): Promise<PlatformAddressInfo[]>;

package/src/platformAddresses/getAddressesInfos.js

@@ -0,0 +1,43 @@
+import { PlatformAddressWASM, verifyPlatformAddressesInfos } from 'pshenmic-dpp';
+import { GetAddressesInfosRequest } from '../../proto/generated/platform.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+export async function getAddressesInfos(grpcPool, platformAddresses) {
+    const platformAddressesWASM = platformAddresses.map(addr => new PlatformAddressWASM(addr));
+    const getAddressInfoRequest = GetAddressesInfosRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                addresses: platformAddressesWASM.map(addr => addr.bytes()),
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getAddressesInfos(getAddressInfoRequest);
+    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, infos } = verifyPlatformAddressesInfos(proof.grovedbProof, platformAddressesWASM, true, LATEST_PLATFORM_VERSION);
+    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 infos
+        .map(info => ({
+        address: info.address,
+        nonce: info.nonce ?? 0,
+        balance: BigInt(info.balance ?? 0)
+    }));
+}

package/src/platformAddresses/index.d.ts

@@ -0,0 +1,22 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { PlatformAddressLike } from 'pshenmic-dpp';
+import { PlatformAddressInfo } from '../../types.js';
+export declare class PlatformAddressesController {
+    /** @ignore **/
+    grpcPool: GRPCConnectionPool;
+    constructor(grpcPool: GRPCConnectionPool);
+    /**
+     * Makes a query for platform address info, returns an object with address, balance and nonce
+     *
+     * @param address {PlatformAddressLike}
+     * @return {Promise<PlatformAddressInfo>}
+     */
+    getAddressInfo(address: PlatformAddressLike): Promise<PlatformAddressInfo>;
+    /**
+     * Makes a query for platform addresses infos, returns array with an object with address, balance and nonce
+     *
+     * @param addresses {PlatformAddressLike[]}
+     * @return {Promise<PlatformAddressInfo[]>}
+     */
+    getAddressesInfos(addresses: PlatformAddressLike[]): Promise<PlatformAddressInfo[]>;
+}

package/src/platformAddresses/index.js

@@ -0,0 +1,27 @@
+import { getAddressInfo } from './getAddressInfo.js';
+import { getAddressesInfos } from './getAddressesInfos.js';
+export class PlatformAddressesController {
+    /** @ignore **/
+    grpcPool;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Makes a query for platform address info, returns an object with address, balance and nonce
+     *
+     * @param address {PlatformAddressLike}
+     * @return {Promise<PlatformAddressInfo>}
+     */
+    async getAddressInfo(address) {
+        return await getAddressInfo(this.grpcPool, address);
+    }
+    /**
+     * Makes a query for platform addresses infos, returns array with an object with address, balance and nonce
+     *
+     * @param addresses {PlatformAddressLike[]}
+     * @return {Promise<PlatformAddressInfo[]>}
+     */
+    async getAddressesInfos(addresses) {
+        return await getAddressesInfos(this.grpcPool, addresses);
+    }
+}

package/src/stateTransitions/broadcast.js

@@ -1,10 +1,21 @@
 import { BroadcastStateTransitionRequest } from '../../proto/generated/platform.js';
+import { deserializeConsensusError } from '../utils/deserializeConsensusError.js';
 export default async function broadcast(grpcPool, stateTransition) {
-    if (stateTransition.signature?.length === 0) {
-        throw new Error('State Transition is not signed');
+    try {
+        if (stateTransition.signature?.length === 0) {
+            throw new Error('State Transition is not signed');
+        }
+        const broadcastStateTransitionRequest = BroadcastStateTransitionRequest.create({
+            stateTransition: stateTransition.bytes()
+        });
+        await grpcPool.getClient().broadcastStateTransition(broadcastStateTransitionRequest);
+    }
+    catch (err) {
+        if (err.meta?.['dash-serialized-consensus-error-bin']?.length !== 0) {
+            throw new Error(deserializeConsensusError(err.meta['dash-serialized-consensus-error-bin']));
+        }
+        else {
+            throw err;
+        }
     }
-    const broadcastStateTransitionRequest = BroadcastStateTransitionRequest.create({
-        stateTransition: stateTransition.bytes()
-    });
-    await grpcPool.getClient().broadcastStateTransition(broadcastStateTransitionRequest);
 }

package/src/tokens/getIdentitiesTokenBalances.d.ts

@@ -1,6 +1,5 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike } from '../../types.js';
-import { IdentifierWASM } from 'pshenmic-dpp';
+import { IdentifierLike, IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentitiesTokenBalances {
     identityId: IdentifierWASM;
     balance?: bigint | undefined;

package/src/tokens/getIdentityTokensBalances.d.ts

@@ -1,6 +1,5 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike } from '../../types.js';
-import { IdentifierWASM } from 'pshenmic-dpp';
+import { IdentifierLike, IdentifierWASM } from 'pshenmic-dpp';
 export interface IdentityTokenBalances {
     tokenId: IdentifierWASM;
     balance?: bigint | undefined;

package/src/tokens/getTokenContractInfo.d.ts

@@ -1,6 +1,5 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike } from '../../types.js';
-import { IdentifierWASM } from 'pshenmic-dpp';
+import { IdentifierLike, IdentifierWASM } from 'pshenmic-dpp';
 export interface TokenContractInfo {
     dataContractId: IdentifierWASM;
     tokenContractPosition: number;

package/src/tokens/getTokenDirectPurchasePrices.d.ts

@@ -1,3 +1,4 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike, TokenDirectPurchasePrices } from '../../types.js';
+import { TokenDirectPurchasePrices } from '../../types.js';
+import { IdentifierLike } from 'pshenmic-dpp';
 export default function getTokenDirectPurchasePrices(grpcPool: GRPCConnectionPool, tokenIdentifiers: IdentifierLike[]): Promise<TokenDirectPurchasePrices[]>;

package/src/tokens/getTokenTotalSupply.d.ts

@@ -1,3 +1,4 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike, TokenTotalSupply } from '../../types.js';
+import { TokenTotalSupply } from '../../types.js';
+import { IdentifierLike } from 'pshenmic-dpp';
 export default function getTokenTotalSupply(grpcPool: GRPCConnectionPool, tokenIdentifier: IdentifierLike): Promise<TokenTotalSupply>;

package/src/tokens/index.d.ts

@@ -1,9 +1,9 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
-import { IdentifierLike, TokenDirectPurchasePrices, TokenTotalSupply, TokenTransitionParams, TokenTransitionType } from '../../types.js';
+import { TokenDirectPurchasePrices, TokenTotalSupply, TokenTransitionParams, TokenTransitionType } from '../../types.js';
 import { IdentitiesTokenBalances } from './getIdentitiesTokenBalances.js';
 import { IdentityTokenBalances } from './getIdentityTokensBalances.js';
 import { TokenContractInfo } from './getTokenContractInfo.js';
-import { StateTransitionWASM, TokenBaseTransitionWASM } from 'pshenmic-dpp';
+import { IdentifierLike, StateTransitionWASM, TokenBaseTransitionWASM } from 'pshenmic-dpp';
 /**
  * Tokens controller for requesting information about tokens and tokens holders
  *

package/src/utils/deserializeConsensusError.d.ts

@@ -0,0 +1 @@
+export declare function deserializeConsensusError(error: string | Uint8Array): string;

package/src/utils/deserializeConsensusError.js

@@ -0,0 +1,17 @@
+import { base64 } from '@scure/base';
+import { ConsensusErrorWASM } from 'pshenmic-dpp';
+export function deserializeConsensusError(error) {
+    let normError;
+    if (typeof error === 'string') {
+        // @scure/base64 works only with padded base64, but cbor can return unpadded base64
+        const padding = error.length % 4;
+        if (padding !== 0) {
+            error += '='.repeat(4 - padding);
+        }
+        normError = base64.decode(error);
+    }
+    else {
+        normError = error;
+    }
+    return ConsensusErrorWASM.deserialize(normError).message;
+}

package/src/utils/index.d.ts

@@ -1,5 +1,4 @@
-import { IdentifierWASM } from 'pshenmic-dpp';
-import { IdentifierLike } from '../../types.js';
+import { IdentifierLike, IdentifierWASM } from 'pshenmic-dpp';
 /**
  * Collection of conversion functions
  *
@@ -70,4 +69,11 @@ export declare class UtilsController {
      * @return {boolean}
      * */
     validateIdentifier(identifier: IdentifierLike): boolean;
+    /**
+     * Allows to deserialize consensus error
+     *
+     * @param error {string | Uint8Array} error in base64 or bytes
+     * @return {string}
+     */
+    deserializeConsensusError(error: string | Uint8Array): string;
 }

package/src/utils/index.js

@@ -5,6 +5,7 @@ import bytesToHex from './bytesToHex.js';
 import { createVoterIdentityId } from './createVoterIdentityId.js';
 import { IdentifierWASM } from 'pshenmic-dpp';
 import { createMasternodeIdentityId } from './createMasternodeIdentityId.js';
+import { deserializeConsensusError } from './deserializeConsensusError.js';
 /**
  * Collection of conversion functions
  *
@@ -98,4 +99,13 @@ export class UtilsController {
             return false;
         }
     }
+    /**
+     * Allows to deserialize consensus error
+     *
+     * @param error {string | Uint8Array} error in base64 or bytes
+     * @return {string}
+     */
+    deserializeConsensusError(error) {
+        return deserializeConsensusError(error);
+    }
 }

package/src/voting/index.d.ts

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

package/test/unit/Document.spec.js

@@ -42,6 +42,35 @@ describe('Document', () => {
         expect(document.dataContractId.base58()).toEqual(dataContract);
         expect(document).toEqual(expect.any(DocumentWASM));
     });
+    test('should be able to get document with startAt', async () => {
+        const dataContract = '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5';
+        const documentType = 'torrent';
+        const limit = 5;
+        // @ts-expect-error
+        const [firstQueriedDoc] = (await sdk.documents.query(dataContract, documentType, null, null, limit)).toReversed();
+        // @ts-expect-error
+        const [secondQueriedDoc] = await sdk.documents.query(dataContract, documentType, null, null, limit, firstQueriedDoc.id);
+        expect(secondQueriedDoc.id.base58()).toEqual(firstQueriedDoc.id.base58());
+        expect(secondQueriedDoc.createdAtBlockHeight).toEqual(undefined);
+        expect(secondQueriedDoc.dataContractId.base58()).toEqual(dataContract);
+        expect(secondQueriedDoc).toEqual(expect.any(DocumentWASM));
+    });
+    test('should be able to get document with startAfter', async () => {
+        const dataContract = '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5';
+        const documentType = 'torrent';
+        const limit = 5;
+        const masterQueryLimit = limit * 2;
+        // @ts-expect-error
+        const masterQuery = await sdk.documents.query(dataContract, documentType, null, null, masterQueryLimit);
+        // @ts-expect-error
+        const [firstQueriedDoc] = (await sdk.documents.query(dataContract, documentType, null, null, limit)).toReversed();
+        // @ts-expect-error
+        const [secondQueriedDoc] = await sdk.documents.query(dataContract, documentType, null, null, limit, undefined, firstQueriedDoc.id);
+        expect(masterQuery[5].id.base58()).toEqual(secondQueriedDoc.id.base58());
+        expect(secondQueriedDoc.createdAtBlockHeight).toEqual(undefined);
+        expect(secondQueriedDoc.dataContractId.base58()).toEqual(dataContract);
+        expect(secondQueriedDoc).toEqual(expect.any(DocumentWASM));
+    });
     describe('should be able to create state transition', () => {
         test('should be able to create a create transition', async () => {
             const document = sdk.documents.create(dataContract, documentType, data, identity);

package/test/unit/PlatformAddress.spec.d.ts

@@ -0,0 +1 @@
+export {};