refactor(sdk)!: cleanup JS SDK params and return types

package.json

@@ -108,7 +108,8 @@
     "brace-expansion": "^2.0.2",
     "cipher-base": "^1.0.5",
     "sha.js": "^2.4.12",
-    "tmp": "^0.2.4"
+    "tmp": "^0.2.4",
+    "js-yaml": "^4.1.1"
   },
   "dependencies": {
     "dompurify": "^3.2.6",

packages/dashmate/package.json

@@ -79,7 +79,7 @@
     "hasbin": "^1.2.3",
     "is-wsl": "2.2.0",
     "jayson": "^4.1.0",
-    "js-yaml": "^4.1.0",
+    "js-yaml": "^4.1.1",
     "listr2": "5.0.7",
     "lodash": "^4.17.21",
     "memory-streams": "^0.1.3",

packages/js-evo-sdk/src/contracts/facade.ts

@@ -14,27 +14,27 @@ export class ContractsFacade {
     return w.getDataContract(contractId);
   }
 
-  async fetchWithProof(contractId: wasm.IdentifierLike): Promise<any> {
+  async fetchWithProof(contractId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<wasm.DataContract>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDataContractWithProofInfo(contractId);
   }
 
-  async getHistory(query: wasm.DataContractHistoryQuery): Promise<any> {
+  async getHistory(query: wasm.DataContractHistoryQuery): Promise<Map<bigint, wasm.DataContract>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDataContractHistory(query);
   }
 
-  async getHistoryWithProof(query: wasm.DataContractHistoryQuery): Promise<any> {
+  async getHistoryWithProof(query: wasm.DataContractHistoryQuery): Promise<wasm.ProofMetadataResponseTyped<Map<bigint, wasm.DataContract>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDataContractHistoryWithProofInfo(query);
   }
 
-  async getMany(contractIds: wasm.IdentifierLike[]): Promise<any> {
+  async getMany(contractIds: wasm.IdentifierLike[]): Promise<Map<wasm.Identifier, wasm.DataContract | undefined>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDataContracts(contractIds);
   }
 
-  async getManyWithProof(contractIds: wasm.IdentifierLike[]): Promise<any> {
+  async getManyWithProof(contractIds: wasm.IdentifierLike[]): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, wasm.DataContract | undefined>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDataContractsWithProofInfo(contractIds);
   }

packages/js-evo-sdk/src/documents/facade.ts

@@ -10,22 +10,22 @@ export class DocumentsFacade {
   }
 
   // Query many documents
-  async query(query: wasm.DocumentsQuery): Promise<any> {
+  async query(query: wasm.DocumentsQuery): Promise<Map<wasm.Identifier, wasm.Document | undefined>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDocuments(query);
   }
 
-  async queryWithProof(query: wasm.DocumentsQuery): Promise<any> {
+  async queryWithProof(query: wasm.DocumentsQuery): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, wasm.Document | undefined>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDocumentsWithProofInfo(query);
   }
 
-  async get(contractId: wasm.IdentifierLike, type: string, documentId: wasm.IdentifierLike): Promise<any> {
+  async get(contractId: wasm.IdentifierLike, type: string, documentId: wasm.IdentifierLike): Promise<wasm.Document | undefined> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDocument(contractId, type, documentId);
   }
 
-  async getWithProof(contractId: wasm.IdentifierLike, type: string, documentId: wasm.IdentifierLike): Promise<any> {
+  async getWithProof(contractId: wasm.IdentifierLike, type: string, documentId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<wasm.Document | undefined>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDocumentWithProofInfo(contractId, type, documentId);
   }

packages/js-evo-sdk/src/dpns/facade.ts

@@ -28,43 +28,43 @@ export class DpnsFacade {
     return w.dpnsIsNameAvailable(label);
   }
 
-  async resolveName(name: string): Promise<any> {
+  async resolveName(name: string): Promise<string | undefined> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.dpnsResolveName(name);
   }
 
-  async registerName(args: { label: string; identityId: wasm.IdentifierLike; publicKeyId: number; privateKeyWif: string; onPreorder?: Function }): Promise<any> {
+  async registerName(args: { label: string; identityId: wasm.IdentifierLike; publicKeyId: number; privateKeyWif: string; onPreorder?: Function }): Promise<wasm.RegisterDpnsNameResult> {
     const { label, identityId, publicKeyId, privateKeyWif, onPreorder } = args;
     const w = await this.sdk.getWasmSdkConnected();
     return w.dpnsRegisterName(label, identityId, publicKeyId, privateKeyWif, onPreorder ?? null);
   }
 
-  async usernames(query: wasm.DpnsUsernamesQuery): Promise<any> {
+  async usernames(query: wasm.DpnsUsernamesQuery): Promise<string[]> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernames(query);
   }
 
-  async username(identityId: wasm.IdentifierLike): Promise<any> {
+  async username(identityId: wasm.IdentifierLike): Promise<string | undefined> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsername(identityId);
   }
 
-  async usernamesWithProof(query: wasm.DpnsUsernamesQuery): Promise<any> {
+  async usernamesWithProof(query: wasm.DpnsUsernamesQuery): Promise<wasm.DpnsUsernamesProofResponse> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernamesWithProofInfo(query);
   }
 
-  async usernameWithProof(identityId: wasm.IdentifierLike): Promise<any> {
+  async usernameWithProof(identityId: wasm.IdentifierLike): Promise<wasm.DpnsUsernameProofResponse> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernameWithProofInfo(identityId);
   }
 
-  async getUsernameByName(username: string): Promise<any> {
+  async getUsernameByName(username: string): Promise<wasm.DpnsUsernameInfo> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernameByName(username);
   }
 
-  async getUsernameByNameWithProof(username: string): Promise<any> {
+  async getUsernameByNameWithProof(username: string): Promise<wasm.ProofMetadataResponseTyped<wasm.DpnsUsernameInfo>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernameByNameWithProofInfo(username);
   }

packages/js-evo-sdk/src/epoch/facade.ts

@@ -1,3 +1,4 @@
+import * as wasm from '../wasm.js';
 import type { EvoSDK } from '../sdk.js';
 import type {
   EpochsQuery,
@@ -9,45 +10,48 @@ export class EpochFacade {
   private sdk: EvoSDK;
   constructor(sdk: EvoSDK) { this.sdk = sdk; }
 
-  async epochsInfo(query: EpochsQuery = {}): Promise<any> {
+  async epochsInfo(query: EpochsQuery = {}): Promise<Map<number, wasm.ExtendedEpochInfo | undefined>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getEpochsInfo(query);
   }
 
-  async epochsInfoWithProof(query: EpochsQuery = {}): Promise<any> {
+  async epochsInfoWithProof(query: EpochsQuery = {}): Promise<wasm.ProofMetadataResponseTyped<Map<number, wasm.ExtendedEpochInfo | undefined>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getEpochsInfoWithProofInfo(query);
   }
 
-  async finalizedInfos(query: FinalizedEpochsQuery): Promise<any> {
+  async finalizedInfos(query: FinalizedEpochsQuery): Promise<Map<number, wasm.FinalizedEpochInfo | undefined>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getFinalizedEpochInfos(query);
   }
 
-  async finalizedInfosWithProof(query: FinalizedEpochsQuery): Promise<any> {
+  async finalizedInfosWithProof(query: FinalizedEpochsQuery): Promise<wasm.ProofMetadataResponseTyped<Map<number, wasm.FinalizedEpochInfo | undefined>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getFinalizedEpochInfosWithProofInfo(query);
   }
 
-  async current(): Promise<any> { const w = await this.sdk.getWasmSdkConnected(); return w.getCurrentEpoch(); }
-  async currentWithProof(): Promise<any> { const w = await this.sdk.getWasmSdkConnected(); return w.getCurrentEpochWithProofInfo(); }
+  async current(): Promise<wasm.ExtendedEpochInfo> { const w = await this.sdk.getWasmSdkConnected(); return w.getCurrentEpoch(); }
+  async currentWithProof(): Promise<wasm.ProofMetadataResponseTyped<wasm.ExtendedEpochInfo>> {
+    const w = await this.sdk.getWasmSdkConnected();
+    return w.getCurrentEpochWithProofInfo();
+  }
 
-  async evonodesProposedBlocksByIds(epoch: number, ids: string[]): Promise<any> {
+  async evonodesProposedBlocksByIds(epoch: number, ids: string[]): Promise<Map<wasm.Identifier, bigint>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getEvonodesProposedEpochBlocksByIds(epoch, ids);
   }
 
-  async evonodesProposedBlocksByIdsWithProof(epoch: number, ids: string[]): Promise<any> {
+  async evonodesProposedBlocksByIdsWithProof(epoch: number, ids: string[]): Promise<wasm.ProofMetadataResponseTyped<unknown>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getEvonodesProposedEpochBlocksByIdsWithProofInfo(epoch, ids);
   }
 
-  async evonodesProposedBlocksByRange(query: EvonodeProposedBlocksRangeQuery): Promise<any> {
+  async evonodesProposedBlocksByRange(query: EvonodeProposedBlocksRangeQuery): Promise<Map<wasm.Identifier, bigint>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getEvonodesProposedEpochBlocksByRange(query);
   }
 
-  async evonodesProposedBlocksByRangeWithProof(query: EvonodeProposedBlocksRangeQuery): Promise<any> {
+  async evonodesProposedBlocksByRangeWithProof(query: EvonodeProposedBlocksRangeQuery): Promise<wasm.ProofMetadataResponseTyped<unknown>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getEvonodesProposedEpochBlocksByRangeWithProofInfo(query);
   }