@dashevo/evo-sdk 2.1.3 → 3.0.0-dev.10

package/dist/group/facade.d.ts

@@ -1,77 +1,24 @@
+import * as wasm from '../wasm.js';
 import type { EvoSDK } from '../sdk.js';
 export declare class GroupFacade {
     private sdk;
     constructor(sdk: EvoSDK);
-    info(contractId: string, groupContractPosition: number): Promise<any>;
-    infoWithProof(contractId: string, groupContractPosition: number): Promise<any>;
-    infos(contractId: string, startAtInfo?: unknown, count?: number): Promise<any>;
-    infosWithProof(contractId: string, startAtInfo?: unknown, count?: number): Promise<any>;
-    members(contractId: string, groupContractPosition: number, opts?: {
-        memberIds?: string[];
-        startAt?: string;
-        limit?: number;
-    }): Promise<any>;
-    membersWithProof(contractId: string, groupContractPosition: number, opts?: {
-        memberIds?: string[];
-        startAt?: string;
-        limit?: number;
-    }): Promise<any>;
-    identityGroups(identityId: string, opts?: {
-        memberDataContracts?: string[];
-        ownerDataContracts?: string[];
-        moderatorDataContracts?: string[];
-    }): Promise<any>;
-    identityGroupsWithProof(identityId: string, opts?: {
-        memberDataContracts?: string[];
-        ownerDataContracts?: string[];
-        moderatorDataContracts?: string[];
-    }): Promise<any>;
-    actions(contractId: string, groupContractPosition: number, status: string, opts?: {
-        startAtInfo?: unknown;
-        count?: number;
-    }): Promise<any>;
-    actionsWithProof(contractId: string, groupContractPosition: number, status: string, opts?: {
-        startAtInfo?: unknown;
-        count?: number;
-    }): Promise<any>;
-    actionSigners(contractId: string, groupContractPosition: number, status: string, actionId: string): Promise<any>;
-    actionSignersWithProof(contractId: string, groupContractPosition: number, status: string, actionId: string): Promise<any>;
-    groupsDataContracts(dataContractIds: string[]): Promise<any>;
-    groupsDataContractsWithProof(dataContractIds: string[]): Promise<any>;
-    contestedResources(params: {
-        documentTypeName: string;
-        contractId: string;
-        indexName: string;
-        startAtValue?: Uint8Array;
-        limit?: number;
-        orderAscending?: boolean;
-    }): Promise<any>;
-    contestedResourcesWithProof(params: {
-        documentTypeName: string;
-        contractId: string;
-        indexName: string;
-        startAtValue?: Uint8Array;
-        limit?: number;
-        orderAscending?: boolean;
-    }): Promise<any>;
-    contestedResourceVotersForIdentity(params: {
-        contractId: string;
-        documentTypeName: string;
-        indexName: string;
-        indexValues: any[];
-        contestantId: string;
-        startAtVoterInfo?: string;
-        limit?: number;
-        orderAscending?: boolean;
-    }): Promise<any>;
-    contestedResourceVotersForIdentityWithProof(params: {
-        contractId: string;
-        documentTypeName: string;
-        indexName: string;
-        indexValues: any[];
-        contestantId: string;
-        startAtIdentifierInfo?: string;
-        count?: number;
-        orderAscending?: boolean;
-    }): Promise<any>;
+    info(contractId: wasm.IdentifierLike, groupContractPosition: number): Promise<wasm.Group | undefined>;
+    infoWithProof(contractId: wasm.IdentifierLike, groupContractPosition: number): Promise<wasm.ProofMetadataResponseTyped<wasm.Group | undefined>>;
+    infos(query: wasm.GroupInfosQuery): Promise<Map<number, wasm.Group | undefined>>;
+    infosWithProof(query: wasm.GroupInfosQuery): Promise<wasm.ProofMetadataResponseTyped<Map<number, wasm.Group | undefined>>>;
+    members(query: wasm.GroupMembersQuery): Promise<Map<wasm.Identifier, bigint>>;
+    membersWithProof(query: wasm.GroupMembersQuery): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, bigint>>>;
+    identityGroups(query: wasm.IdentityGroupsQuery): Promise<wasm.IdentityGroupInfo[]>;
+    identityGroupsWithProof(query: wasm.IdentityGroupsQuery): Promise<wasm.ProofMetadataResponseTyped<wasm.IdentityGroupInfo[]>>;
+    actions(query: wasm.GroupActionsQuery): Promise<Map<wasm.Identifier, wasm.GroupAction | undefined>>;
+    actionsWithProof(query: wasm.GroupActionsQuery): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, wasm.GroupAction | undefined>>>;
+    actionSigners(query: wasm.GroupActionSignersQuery): Promise<Map<wasm.Identifier, bigint>>;
+    actionSignersWithProof(query: wasm.GroupActionSignersQuery): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, bigint>>>;
+    groupsDataContracts(dataContractIds: wasm.IdentifierLike[]): Promise<Map<wasm.Identifier, Map<number, wasm.Group | undefined>>>;
+    groupsDataContractsWithProof(dataContractIds: wasm.IdentifierLike[]): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, Map<number, wasm.Group | undefined>>>>;
+    contestedResources(query: wasm.VotePollsByDocumentTypeQuery): Promise<any[]>;
+    contestedResourcesWithProof(query: wasm.VotePollsByDocumentTypeQuery): Promise<wasm.ProofMetadataResponseTyped<Array<any>>>;
+    contestedResourceVotersForIdentity(query: wasm.ContestedResourceVotersForIdentityQuery): Promise<wasm.Identifier[]>;
+    contestedResourceVotersForIdentityWithProof(query: wasm.ContestedResourceVotersForIdentityQuery): Promise<wasm.ProofMetadataResponseTyped<wasm.Identifier[]>>;
 }

package/dist/group/facade.js

@@ -8,51 +8,45 @@ export class GroupFacade {
         const w = await this.sdk.getWasmSdkConnected();
         return w.getGroupInfoWithProofInfo(contractId, groupContractPosition);
     }
-    async infos(contractId, startAtInfo, count) {
+    async infos(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupInfos(contractId, startAtInfo ?? null, count ?? null);
+        return w.getGroupInfos(query);
     }
-    async infosWithProof(contractId, startAtInfo, count) {
+    async infosWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupInfosWithProofInfo(contractId, startAtInfo ?? null, count ?? null);
+        return w.getGroupInfosWithProofInfo(query);
     }
-    async members(contractId, groupContractPosition, opts = {}) {
-        const { memberIds, startAt, limit } = opts;
+    async members(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupMembers(contractId, groupContractPosition, memberIds ?? null, startAt ?? null, limit ?? null);
+        return w.getGroupMembers(query);
     }
-    async membersWithProof(contractId, groupContractPosition, opts = {}) {
-        const { memberIds, startAt, limit } = opts;
+    async membersWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupMembersWithProofInfo(contractId, groupContractPosition, memberIds ?? null, startAt ?? null, limit ?? null);
+        return w.getGroupMembersWithProofInfo(query);
     }
-    async identityGroups(identityId, opts = {}) {
-        const { memberDataContracts, ownerDataContracts, moderatorDataContracts } = opts;
+    async identityGroups(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentityGroups(identityId, memberDataContracts ?? null, ownerDataContracts ?? null, moderatorDataContracts ?? null);
+        return w.getIdentityGroups(query);
     }
-    async identityGroupsWithProof(identityId, opts = {}) {
-        const { memberDataContracts, ownerDataContracts, moderatorDataContracts } = opts;
+    async identityGroupsWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentityGroupsWithProofInfo(identityId, memberDataContracts ?? null, ownerDataContracts ?? null, moderatorDataContracts ?? null);
+        return w.getIdentityGroupsWithProofInfo(query);
     }
-    async actions(contractId, groupContractPosition, status, opts = {}) {
-        const { startAtInfo, count } = opts;
+    async actions(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupActions(contractId, groupContractPosition, status, startAtInfo ?? null, count ?? null);
+        return w.getGroupActions(query);
     }
-    async actionsWithProof(contractId, groupContractPosition, status, opts = {}) {
-        const { startAtInfo, count } = opts;
+    async actionsWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupActionsWithProofInfo(contractId, groupContractPosition, status, startAtInfo ?? null, count ?? null);
+        return w.getGroupActionsWithProofInfo(query);
     }
-    async actionSigners(contractId, groupContractPosition, status, actionId) {
+    async actionSigners(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupActionSigners(contractId, groupContractPosition, status, actionId);
+        return w.getGroupActionSigners(query);
     }
-    async actionSignersWithProof(contractId, groupContractPosition, status, actionId) {
+    async actionSignersWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getGroupActionSignersWithProofInfo(contractId, groupContractPosition, status, actionId);
+        return w.getGroupActionSignersWithProofInfo(query);
     }
     async groupsDataContracts(dataContractIds) {
         const w = await this.sdk.getWasmSdkConnected();
@@ -62,24 +56,20 @@ export class GroupFacade {
         const w = await this.sdk.getWasmSdkConnected();
         return w.getGroupsDataContractsWithProofInfo(dataContractIds);
     }
-    async contestedResources(params) {
-        const { documentTypeName, contractId, indexName, startAtValue, limit, orderAscending } = params;
+    async contestedResources(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getContestedResources(documentTypeName, contractId, indexName, startAtValue ?? null, limit ?? null, null, orderAscending ?? null);
+        return w.getContestedResources(query);
     }
-    async contestedResourcesWithProof(params) {
-        const { documentTypeName, contractId, indexName, startAtValue, limit, orderAscending } = params;
+    async contestedResourcesWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getContestedResourcesWithProofInfo(documentTypeName, contractId, indexName, startAtValue ?? null, limit ?? null, null, orderAscending ?? null);
+        return w.getContestedResourcesWithProofInfo(query);
     }
-    async contestedResourceVotersForIdentity(params) {
-        const { contractId, documentTypeName, indexName, indexValues, contestantId, startAtVoterInfo, limit, orderAscending } = params;
+    async contestedResourceVotersForIdentity(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getContestedResourceVotersForIdentity(contractId, documentTypeName, indexName, indexValues, contestantId, startAtVoterInfo ?? null, limit ?? null, orderAscending ?? null);
+        return w.getContestedResourceVotersForIdentity(query);
     }
-    async contestedResourceVotersForIdentityWithProof(params) {
-        const { contractId, documentTypeName, indexName, indexValues, contestantId, startAtIdentifierInfo, count, orderAscending } = params;
+    async contestedResourceVotersForIdentityWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getContestedResourceVotersForIdentityWithProofInfo(contractId, documentTypeName, indexName, indexValues, contestantId, startAtIdentifierInfo ?? null, count ?? null, orderAscending ?? null);
+        return w.getContestedResourceVotersForIdentityWithProofInfo(query);
     }
 }

package/dist/identities/facade.d.ts

@@ -3,73 +3,48 @@ import type { EvoSDK } from '../sdk.js';
 export declare class IdentitiesFacade {
     private sdk;
     constructor(sdk: EvoSDK);
-    fetch(identityId: string): Promise<wasm.IdentityWasm>;
-    fetchWithProof(identityId: string): Promise<any>;
-    fetchUnproved(identityId: string): Promise<wasm.IdentityWasm>;
-    getKeys(args: {
-        identityId: string;
-        keyRequestType: 'all' | 'specific' | 'search';
-        specificKeyIds?: number[];
-        searchPurposeMap?: unknown;
-        limit?: number;
-        offset?: number;
-    }): Promise<any>;
-    getKeysWithProof(args: {
-        identityId: string;
-        keyRequestType: 'all' | 'specific' | 'search';
-        specificKeyIds?: number[];
-        limit?: number;
-        offset?: number;
-    }): Promise<any>;
-    nonce(identityId: string): Promise<any>;
-    nonceWithProof(identityId: string): Promise<any>;
-    contractNonce(identityId: string, contractId: string): Promise<any>;
-    contractNonceWithProof(identityId: string, contractId: string): Promise<any>;
-    balance(identityId: string): Promise<any>;
-    balanceWithProof(identityId: string): Promise<any>;
-    balances(identityIds: string[]): Promise<any>;
-    balancesWithProof(identityIds: string[]): Promise<any>;
-    balanceAndRevision(identityId: string): Promise<any>;
-    balanceAndRevisionWithProof(identityId: string): Promise<any>;
-    byPublicKeyHash(publicKeyHash: string): Promise<wasm.IdentityWasm>;
-    byPublicKeyHashWithProof(publicKeyHash: string): Promise<any>;
-    byNonUniquePublicKeyHash(publicKeyHash: string, opts?: {
-        startAfter?: string;
-    }): Promise<any>;
-    byNonUniquePublicKeyHashWithProof(publicKeyHash: string, opts?: {
-        startAfter?: string;
-    }): Promise<any>;
-    contractKeys(args: {
-        identityIds: string[];
-        contractId: string;
-        purposes?: number[];
-    }): Promise<any>;
-    contractKeysWithProof(args: {
-        identityIds: string[];
-        contractId: string;
-        purposes?: number[];
-    }): Promise<any>;
-    tokenBalances(identityId: string, tokenIds: string[]): Promise<any>;
-    tokenBalancesWithProof(identityId: string, tokenIds: string[]): Promise<any>;
+    fetch(identityId: wasm.IdentifierLike): Promise<wasm.Identity | undefined>;
+    fetchWithProof(identityId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<wasm.Identity>>;
+    fetchUnproved(identityId: wasm.IdentifierLike): Promise<wasm.Identity>;
+    getKeys(query: wasm.IdentityKeysQuery): Promise<wasm.IdentityKeyInfo[]>;
+    getKeysWithProof(query: wasm.IdentityKeysQuery): Promise<wasm.ProofMetadataResponseTyped<wasm.IdentityKeyInfo[]>>;
+    nonce(identityId: wasm.IdentifierLike): Promise<bigint | null>;
+    nonceWithProof(identityId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<bigint | null>>;
+    contractNonce(identityId: wasm.IdentifierLike, contractId: wasm.IdentifierLike): Promise<bigint | null>;
+    contractNonceWithProof(identityId: wasm.IdentifierLike, contractId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<bigint | null>>;
+    balance(identityId: wasm.IdentifierLike): Promise<bigint | null>;
+    balanceWithProof(identityId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<bigint | null>>;
+    balances(identityIds: wasm.IdentifierLike[]): Promise<Map<wasm.Identifier, bigint | null>>;
+    balancesWithProof(identityIds: wasm.IdentifierLike[]): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, bigint | null>>>;
+    balanceAndRevision(identityId: wasm.IdentifierLike): Promise<wasm.IdentityBalanceAndRevision | null>;
+    balanceAndRevisionWithProof(identityId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<wasm.IdentityBalanceAndRevision | null>>;
+    byPublicKeyHash(publicKeyHash: string | Uint8Array): Promise<wasm.Identity | null>;
+    byPublicKeyHashWithProof(publicKeyHash: string | Uint8Array): Promise<wasm.ProofMetadataResponseTyped<wasm.Identity | null>>;
+    byNonUniquePublicKeyHash(publicKeyHash: string | Uint8Array, startAfter?: wasm.IdentifierLike): Promise<wasm.Identity[]>;
+    byNonUniquePublicKeyHashWithProof(publicKeyHash: string | Uint8Array, startAfter?: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<wasm.Identity[]>>;
+    contractKeys(query: wasm.IdentitiesContractKeysQuery): Promise<wasm.IdentityContractKeys[]>;
+    contractKeysWithProof(query: wasm.IdentitiesContractKeysQuery): Promise<wasm.ProofMetadataResponseTyped<wasm.IdentityContractKeys[]>>;
+    tokenBalances(identityId: wasm.IdentifierLike, tokenIds: wasm.IdentifierLike[]): Promise<Map<wasm.Identifier, bigint>>;
+    tokenBalancesWithProof(identityId: wasm.IdentifierLike, tokenIds: wasm.IdentifierLike[]): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, bigint>>>;
     create(args: {
         assetLockProof: unknown;
         assetLockPrivateKeyWif: string;
         publicKeys: unknown[];
     }): Promise<any>;
     topUp(args: {
-        identityId: string;
+        identityId: wasm.IdentifierLike;
         assetLockProof: unknown;
         assetLockPrivateKeyWif: string;
     }): Promise<any>;
     creditTransfer(args: {
-        senderId: string;
-        recipientId: string;
+        senderId: wasm.IdentifierLike;
+        recipientId: wasm.IdentifierLike;
         amount: number | bigint | string;
         privateKeyWif: string;
         keyId?: number;
     }): Promise<any>;
     creditWithdrawal(args: {
-        identityId: string;
+        identityId: wasm.IdentifierLike;
         toAddress: string;
         amount: number | bigint | string;
         coreFeePerByte?: number;
@@ -77,7 +52,7 @@ export declare class IdentitiesFacade {
         keyId?: number;
     }): Promise<any>;
     update(args: {
-        identityId: string;
+        identityId: wasm.IdentifierLike;
         addPublicKeys?: unknown[];
         disablePublicKeyIds?: number[];
         privateKeyWif: string;

package/dist/identities/facade.js

@@ -15,16 +15,13 @@ export class IdentitiesFacade {
         const w = await this.sdk.getWasmSdkConnected();
         return w.getIdentityUnproved(identityId);
     }
-    async getKeys(args) {
-        const { identityId, keyRequestType, specificKeyIds, searchPurposeMap, limit, offset } = args;
-        const mapJson = asJsonString(searchPurposeMap);
+    async getKeys(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentityKeys(identityId, keyRequestType, specificKeyIds ? Uint32Array.from(specificKeyIds) : null, mapJson ?? null, limit ?? null, offset ?? null);
+        return w.getIdentityKeys(query);
     }
-    async getKeysWithProof(args) {
-        const { identityId, keyRequestType, specificKeyIds, limit, offset } = args;
+    async getKeysWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentityKeysWithProofInfo(identityId, keyRequestType, specificKeyIds ? Uint32Array.from(specificKeyIds) : null, limit ?? null, offset ?? null);
+        return w.getIdentityKeysWithProofInfo(query);
     }
     async nonce(identityId) {
         const w = await this.sdk.getWasmSdkConnected();
@@ -74,27 +71,21 @@ export class IdentitiesFacade {
         const w = await this.sdk.getWasmSdkConnected();
         return w.getIdentityByPublicKeyHashWithProofInfo(publicKeyHash);
     }
-    async byNonUniquePublicKeyHash(publicKeyHash, opts = {}) {
-        const { startAfter } = opts;
+    async byNonUniquePublicKeyHash(publicKeyHash, startAfter) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentityByNonUniquePublicKeyHash(publicKeyHash, startAfter ?? null);
+        return w.getIdentityByNonUniquePublicKeyHash(publicKeyHash, startAfter);
     }
-    async byNonUniquePublicKeyHashWithProof(publicKeyHash, opts = {}) {
-        const { startAfter } = opts;
+    async byNonUniquePublicKeyHashWithProof(publicKeyHash, startAfter) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentityByNonUniquePublicKeyHashWithProofInfo(publicKeyHash, startAfter ?? null);
+        return w.getIdentityByNonUniquePublicKeyHashWithProofInfo(publicKeyHash, startAfter || undefined);
     }
-    async contractKeys(args) {
-        const { identityIds, contractId, purposes } = args;
-        const purposesArray = purposes && purposes.length > 0 ? Uint32Array.from(purposes) : null;
+    async contractKeys(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentitiesContractKeys(identityIds, contractId, purposesArray);
+        return w.getIdentitiesContractKeys(query);
     }
-    async contractKeysWithProof(args) {
-        const { identityIds, contractId, purposes } = args;
-        const purposesArray = purposes && purposes.length > 0 ? Uint32Array.from(purposes) : null;
+    async contractKeysWithProof(query) {
         const w = await this.sdk.getWasmSdkConnected();
-        return w.getIdentitiesContractKeysWithProofInfo(identityIds, contractId, purposesArray);
+        return w.getIdentitiesContractKeysWithProofInfo(query);
     }
     async tokenBalances(identityId, tokenIds) {
         const w = await this.sdk.getWasmSdkConnected();

package/dist/protocol/facade.d.ts

@@ -1,15 +1,10 @@
 import type { EvoSDK } from '../sdk.js';
+import * as wasm from '../wasm.js';
 export declare class ProtocolFacade {
     private sdk;
     constructor(sdk: EvoSDK);
-    versionUpgradeState(): Promise<any>;
-    versionUpgradeStateWithProof(): Promise<any>;
-    versionUpgradeVoteStatus(params: {
-        startProTxHash: string;
-        count: number;
-    }): Promise<any>;
-    versionUpgradeVoteStatusWithProof(params: {
-        startProTxHash: string;
-        count: number;
-    }): Promise<any>;
+    versionUpgradeState(): Promise<wasm.ProtocolVersionUpgradeState>;
+    versionUpgradeStateWithProof(): Promise<wasm.ProofMetadataResponseTyped<wasm.ProtocolVersionUpgradeState>>;
+    versionUpgradeVoteStatus(startProTxHash: string | Uint8Array, count: number): Promise<Map<string, wasm.ProtocolVersionUpgradeVoteStatus>>;
+    versionUpgradeVoteStatusWithProof(startProTxHash: string | Uint8Array, count: number): Promise<wasm.ProofMetadataResponseTyped<unknown>>;
 }

package/dist/protocol/facade.js

@@ -1,14 +1,18 @@
 export class ProtocolFacade {
     constructor(sdk) { this.sdk = sdk; }
-    async versionUpgradeState() { const w = await this.sdk.getWasmSdkConnected(); return w.getProtocolVersionUpgradeState(); }
-    async versionUpgradeStateWithProof() { const w = await this.sdk.getWasmSdkConnected(); return w.getProtocolVersionUpgradeStateWithProofInfo(); }
-    async versionUpgradeVoteStatus(params) {
-        const { startProTxHash, count } = params;
+    async versionUpgradeState() {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getProtocolVersionUpgradeState();
+    }
+    async versionUpgradeStateWithProof() {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getProtocolVersionUpgradeStateWithProofInfo();
+    }
+    async versionUpgradeVoteStatus(startProTxHash, count) {
         const w = await this.sdk.getWasmSdkConnected();
         return w.getProtocolVersionUpgradeVoteStatus(startProTxHash, count);
     }
-    async versionUpgradeVoteStatusWithProof(params) {
-        const { startProTxHash, count } = params;
+    async versionUpgradeVoteStatusWithProof(startProTxHash, count) {
         const w = await this.sdk.getWasmSdkConnected();
         return w.getProtocolVersionUpgradeVoteStatusWithProofInfo(startProTxHash, count);
     }

package/dist/sdk.d.ts

@@ -1,4 +1,5 @@
 import * as wasm from './wasm.js';
+import { AddressesFacade } from './addresses/facade.js';
 import { DocumentsFacade } from './documents/facade.js';
 import { IdentitiesFacade } from './identities/facade.js';
 import { ContractsFacade } from './contracts/facade.js';
@@ -21,13 +22,14 @@ export interface ConnectionOptions {
     };
 }
 export interface EvoSDKOptions extends ConnectionOptions {
-    network?: 'testnet' | 'mainnet';
+    network?: 'testnet' | 'mainnet' | 'local';
     trusted?: boolean;
     addresses?: string[];
 }
 export declare class EvoSDK {
     private wasmSdk?;
     private options;
+    addresses: AddressesFacade;
     documents: DocumentsFacade;
     identities: IdentitiesFacade;
     contracts: ContractsFacade;
@@ -51,6 +53,8 @@ export declare class EvoSDK {
     static mainnet(options?: ConnectionOptions): EvoSDK;
     static testnetTrusted(options?: ConnectionOptions): EvoSDK;
     static mainnetTrusted(options?: ConnectionOptions): EvoSDK;
+    static local(options?: ConnectionOptions): EvoSDK;
+    static localTrusted(options?: ConnectionOptions): EvoSDK;
     /**
      * Create an EvoSDK instance configured with specific masternode addresses.
      *
@@ -65,8 +69,9 @@ export declare class EvoSDK {
      * await sdk.connect();
      * ```
      */
-    static withAddresses(addresses: string[], network?: 'mainnet' | 'testnet', options?: ConnectionOptions): EvoSDK;
+    static withAddresses(addresses: string[], network?: 'mainnet' | 'testnet' | 'local', options?: ConnectionOptions): EvoSDK;
 }
+export { AddressesFacade } from './addresses/facade.js';
 export { DocumentsFacade } from './documents/facade.js';
 export { IdentitiesFacade } from './identities/facade.js';
 export { ContractsFacade } from './contracts/facade.js';

package/dist/sdk.js

@@ -1,5 +1,6 @@
 import * as wasm from './wasm.js';
 import { ensureInitialized as initWasm } from './wasm.js';
+import { AddressesFacade } from './addresses/facade.js';
 import { DocumentsFacade } from './documents/facade.js';
 import { IdentitiesFacade } from './identities/facade.js';
 import { ContractsFacade } from './contracts/facade.js';
@@ -15,6 +16,7 @@ export class EvoSDK {
         // Apply defaults while preserving any future connection options
         const { network = 'testnet', trusted = false, addresses, ...connection } = options;
         this.options = { network, trusted, addresses, ...connection };
+        this.addresses = new AddressesFacade(this);
         this.documents = new DocumentsFacade(this);
         this.identities = new IdentitiesFacade(this);
         this.contracts = new ContractsFacade(this);
@@ -53,6 +55,9 @@ export class EvoSDK {
             else if (network === 'testnet') {
                 await wasm.WasmSdk.prefetchTrustedQuorumsTestnet();
             }
+            else if (network === 'local') {
+                await wasm.WasmSdk.prefetchTrustedQuorumsLocal();
+            }
             builder = wasm.WasmSdkBuilder.withAddresses(addresses, network);
         }
         else if (network === 'mainnet') {
@@ -63,6 +68,11 @@ export class EvoSDK {
             await wasm.WasmSdk.prefetchTrustedQuorumsTestnet();
             builder = trusted ? wasm.WasmSdkBuilder.testnetTrusted() : wasm.WasmSdkBuilder.testnet();
         }
+        else if (network === 'local') {
+            // Default local dashmate gateway and quorum list sidecar
+            await wasm.WasmSdk.prefetchTrustedQuorumsLocal();
+            builder = trusted ? wasm.WasmSdkBuilder.localTrusted() : wasm.WasmSdkBuilder.local();
+        }
         else {
             throw new Error(`Unknown network: ${network}`);
         }
@@ -99,6 +109,8 @@ export class EvoSDK {
     static mainnet(options = {}) { return new EvoSDK({ network: 'mainnet', ...options }); }
     static testnetTrusted(options = {}) { return new EvoSDK({ network: 'testnet', trusted: true, ...options }); }
     static mainnetTrusted(options = {}) { return new EvoSDK({ network: 'mainnet', trusted: true, ...options }); }
+    static local(options = {}) { return new EvoSDK({ network: 'local', ...options }); }
+    static localTrusted(options = {}) { return new EvoSDK({ network: 'local', trusted: true, ...options }); }
     /**
      * Create an EvoSDK instance configured with specific masternode addresses.
      *
@@ -117,6 +129,7 @@ export class EvoSDK {
         return new EvoSDK({ addresses, network, ...options });
     }
 }
+export { AddressesFacade } from './addresses/facade.js';
 export { DocumentsFacade } from './documents/facade.js';
 export { IdentitiesFacade } from './identities/facade.js';
 export { ContractsFacade } from './contracts/facade.js';

package/dist/system/facade.d.ts

@@ -1,14 +1,15 @@
+import * as wasm from '../wasm.js';
 import type { EvoSDK } from '../sdk.js';
 export declare class SystemFacade {
     private sdk;
     constructor(sdk: EvoSDK);
-    status(): Promise<any>;
-    currentQuorumsInfo(): Promise<any>;
-    totalCreditsInPlatform(): Promise<any>;
-    totalCreditsInPlatformWithProof(): Promise<any>;
-    prefundedSpecializedBalance(identityId: string): Promise<any>;
-    prefundedSpecializedBalanceWithProof(identityId: string): Promise<any>;
-    waitForStateTransitionResult(stateTransitionHash: string): Promise<any>;
-    pathElements(path: string[], keys: string[]): Promise<any>;
-    pathElementsWithProof(path: string[], keys: string[]): Promise<any>;
+    status(): Promise<wasm.StatusResponse>;
+    currentQuorumsInfo(): Promise<wasm.CurrentQuorumsInfo>;
+    totalCreditsInPlatform(): Promise<bigint | undefined>;
+    totalCreditsInPlatformWithProof(): Promise<wasm.ProofMetadataResponseTyped<bigint | undefined>>;
+    prefundedSpecializedBalance(identityId: wasm.IdentifierLike): Promise<wasm.PrefundedSpecializedBalance | undefined>;
+    prefundedSpecializedBalanceWithProof(identityId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<wasm.PrefundedSpecializedBalance | undefined>>;
+    waitForStateTransitionResult(stateTransitionHash: string): Promise<wasm.StateTransitionResult>;
+    pathElements(path: string[], keys: string[]): Promise<wasm.PathElement[]>;
+    pathElementsWithProof(path: string[], keys: string[]): Promise<wasm.ProofMetadataResponseTyped<wasm.PathElement[]>>;
 }

package/dist/system/facade.js

@@ -1,12 +1,39 @@
 export class SystemFacade {
     constructor(sdk) { this.sdk = sdk; }
-    async status() { const w = await this.sdk.getWasmSdkConnected(); return w.getStatus(); }
-    async currentQuorumsInfo() { const w = await this.sdk.getWasmSdkConnected(); return w.getCurrentQuorumsInfo(); }
-    async totalCreditsInPlatform() { const w = await this.sdk.getWasmSdkConnected(); return w.getTotalCreditsInPlatform(); }
-    async totalCreditsInPlatformWithProof() { const w = await this.sdk.getWasmSdkConnected(); return w.getTotalCreditsInPlatformWithProofInfo(); }
-    async prefundedSpecializedBalance(identityId) { const w = await this.sdk.getWasmSdkConnected(); return w.getPrefundedSpecializedBalance(identityId); }
-    async prefundedSpecializedBalanceWithProof(identityId) { const w = await this.sdk.getWasmSdkConnected(); return w.getPrefundedSpecializedBalanceWithProofInfo(identityId); }
-    async waitForStateTransitionResult(stateTransitionHash) { const w = await this.sdk.getWasmSdkConnected(); return w.waitForStateTransitionResult(stateTransitionHash); }
-    async pathElements(path, keys) { const w = await this.sdk.getWasmSdkConnected(); return w.getPathElements(path, keys); }
-    async pathElementsWithProof(path, keys) { const w = await this.sdk.getWasmSdkConnected(); return w.getPathElementsWithProofInfo(path, keys); }
+    async status() {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getStatus();
+    }
+    async currentQuorumsInfo() {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getCurrentQuorumsInfo();
+    }
+    async totalCreditsInPlatform() {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getTotalCreditsInPlatform();
+    }
+    async totalCreditsInPlatformWithProof() {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getTotalCreditsInPlatformWithProofInfo();
+    }
+    async prefundedSpecializedBalance(identityId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getPrefundedSpecializedBalance(identityId);
+    }
+    async prefundedSpecializedBalanceWithProof(identityId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getPrefundedSpecializedBalanceWithProofInfo(identityId);
+    }
+    async waitForStateTransitionResult(stateTransitionHash) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.waitForStateTransitionResult(stateTransitionHash);
+    }
+    async pathElements(path, keys) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getPathElements(path, keys);
+    }
+    async pathElementsWithProof(path, keys) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getPathElementsWithProofInfo(path, keys);
+    }
 }