@dashevo/evo-sdk 2.1.0-dev.4

package/dist/contracts/facade.d.ts

@@ -0,0 +1,33 @@
+import * as wasm from '../wasm.js';
+import type { EvoSDK } from '../sdk.js';
+export declare class ContractsFacade {
+    private sdk;
+    constructor(sdk: EvoSDK);
+    fetch(contractId: string): Promise<wasm.DataContractWasm>;
+    fetchWithProof(contractId: string): Promise<any>;
+    getHistory(args: {
+        contractId: string;
+        limit?: number;
+        startAtMs?: number | bigint;
+    }): Promise<any>;
+    getHistoryWithProof(args: {
+        contractId: string;
+        limit?: number;
+        startAtMs?: number | bigint;
+    }): Promise<any>;
+    getMany(contractIds: string[]): Promise<any>;
+    getManyWithProof(contractIds: string[]): Promise<any>;
+    create(args: {
+        ownerId: string;
+        definition: unknown;
+        privateKeyWif: string;
+        keyId?: number;
+    }): Promise<any>;
+    update(args: {
+        contractId: string;
+        ownerId: string;
+        updates: unknown;
+        privateKeyWif: string;
+        keyId?: number;
+    }): Promise<any>;
+}

package/dist/contracts/facade.js

@@ -0,0 +1,42 @@
+import { asJsonString } from '../util.js';
+export class ContractsFacade {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async fetch(contractId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDataContract(contractId);
+    }
+    async fetchWithProof(contractId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDataContractWithProofInfo(contractId);
+    }
+    async getHistory(args) {
+        const { contractId, limit, startAtMs } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDataContractHistory(contractId, limit ?? null, null, startAtMs != null ? BigInt(startAtMs) : null);
+    }
+    async getHistoryWithProof(args) {
+        const { contractId, limit, startAtMs } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDataContractHistoryWithProofInfo(contractId, limit ?? null, null, startAtMs != null ? BigInt(startAtMs) : null);
+    }
+    async getMany(contractIds) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDataContracts(contractIds);
+    }
+    async getManyWithProof(contractIds) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDataContractsWithProofInfo(contractIds);
+    }
+    async create(args) {
+        const { ownerId, definition, privateKeyWif, keyId } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.contractCreate(ownerId, asJsonString(definition), privateKeyWif, keyId ?? null);
+    }
+    async update(args) {
+        const { contractId, ownerId, updates, privateKeyWif, keyId } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.contractUpdate(contractId, ownerId, asJsonString(updates), privateKeyWif, keyId ?? null);
+    }
+}

package/dist/documents/facade.d.ts

@@ -0,0 +1,73 @@
+import type { EvoSDK } from '../sdk.js';
+export declare class DocumentsFacade {
+    private sdk;
+    constructor(sdk: EvoSDK);
+    query(params: {
+        contractId: string;
+        type: string;
+        where?: unknown;
+        orderBy?: unknown;
+        limit?: number;
+        startAfter?: string;
+        startAt?: string;
+    }): Promise<any>;
+    queryWithProof(params: {
+        contractId: string;
+        type: string;
+        where?: unknown;
+        orderBy?: unknown;
+        limit?: number;
+        startAfter?: string;
+        startAt?: string;
+    }): Promise<any>;
+    get(contractId: string, type: string, documentId: string): Promise<any>;
+    getWithProof(contractId: string, type: string, documentId: string): Promise<any>;
+    create(args: {
+        contractId: string;
+        type: string;
+        ownerId: string;
+        data: unknown;
+        entropyHex: string;
+        privateKeyWif: string;
+    }): Promise<any>;
+    replace(args: {
+        contractId: string;
+        type: string;
+        documentId: string;
+        ownerId: string;
+        data: unknown;
+        revision: number | bigint;
+        privateKeyWif: string;
+    }): Promise<any>;
+    delete(args: {
+        contractId: string;
+        type: string;
+        documentId: string;
+        ownerId: string;
+        privateKeyWif: string;
+    }): Promise<any>;
+    transfer(args: {
+        contractId: string;
+        type: string;
+        documentId: string;
+        ownerId: string;
+        recipientId: string;
+        privateKeyWif: string;
+    }): Promise<any>;
+    purchase(args: {
+        contractId: string;
+        type: string;
+        documentId: string;
+        buyerId: string;
+        price: number | bigint | string;
+        privateKeyWif: string;
+    }): Promise<any>;
+    setPrice(args: {
+        contractId: string;
+        type: string;
+        documentId: string;
+        ownerId: string;
+        price: number | bigint | string;
+        privateKeyWif: string;
+    }): Promise<any>;
+}

package/dist/documents/facade.js

@@ -0,0 +1,59 @@
+import { asJsonString } from '../util.js';
+export class DocumentsFacade {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    // Query many documents
+    async query(params) {
+        const { contractId, type, where, orderBy, limit, startAfter, startAt } = params;
+        const whereJson = asJsonString(where);
+        const orderJson = asJsonString(orderBy);
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDocuments(contractId, type, whereJson ?? null, orderJson ?? null, limit ?? null, startAfter ?? null, startAt ?? null);
+    }
+    async queryWithProof(params) {
+        const { contractId, type, where, orderBy, limit, startAfter, startAt } = params;
+        const whereJson = asJsonString(where);
+        const orderJson = asJsonString(orderBy);
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDocumentsWithProofInfo(contractId, type, whereJson ?? null, orderJson ?? null, limit ?? null, startAfter ?? null, startAt ?? null);
+    }
+    async get(contractId, type, documentId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDocument(contractId, type, documentId);
+    }
+    async getWithProof(contractId, type, documentId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDocumentWithProofInfo(contractId, type, documentId);
+    }
+    async create(args) {
+        const { contractId, type, ownerId, data, entropyHex, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.documentCreate(contractId, type, ownerId, asJsonString(data), entropyHex, privateKeyWif);
+    }
+    async replace(args) {
+        const { contractId, type, documentId, ownerId, data, revision, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.documentReplace(contractId, type, documentId, ownerId, asJsonString(data), BigInt(revision), privateKeyWif);
+    }
+    async delete(args) {
+        const { contractId, type, documentId, ownerId, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.documentDelete(contractId, type, documentId, ownerId, privateKeyWif);
+    }
+    async transfer(args) {
+        const { contractId, type, documentId, ownerId, recipientId, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.documentTransfer(contractId, type, documentId, ownerId, recipientId, privateKeyWif);
+    }
+    async purchase(args) {
+        const { contractId, type, documentId, buyerId, price, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.documentPurchase(contractId, type, documentId, buyerId, BigInt(price), privateKeyWif);
+    }
+    async setPrice(args) {
+        const { contractId, type, documentId, ownerId, price, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.documentSetPrice(contractId, type, documentId, ownerId, BigInt(price), privateKeyWif);
+    }
+}

package/dist/dpns/facade.d.ts

@@ -0,0 +1,27 @@
+import type { EvoSDK } from '../sdk.js';
+export declare class DpnsFacade {
+    private sdk;
+    constructor(sdk: EvoSDK);
+    convertToHomographSafe(input: string): string;
+    isValidUsername(label: string): boolean;
+    isContestedUsername(label: string): boolean;
+    isNameAvailable(label: string): Promise<boolean>;
+    resolveName(name: string): Promise<any>;
+    registerName(args: {
+        label: string;
+        identityId: string;
+        publicKeyId: number;
+        privateKeyWif: string;
+        onPreorder?: Function;
+    }): Promise<any>;
+    usernames(identityId: string, opts?: {
+        limit?: number;
+    }): Promise<any>;
+    username(identityId: string): Promise<any>;
+    usernamesWithProof(identityId: string, opts?: {
+        limit?: number;
+    }): Promise<any>;
+    usernameWithProof(identityId: string): Promise<any>;
+    getUsernameByName(username: string): Promise<any>;
+    getUsernameByNameWithProof(username: string): Promise<any>;
+}

package/dist/dpns/facade.js

@@ -0,0 +1,54 @@
+import * as wasm from '../wasm.js';
+export class DpnsFacade {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    convertToHomographSafe(input) {
+        return wasm.WasmSdk.dpnsConvertToHomographSafe(input);
+    }
+    isValidUsername(label) {
+        return wasm.WasmSdk.dpnsIsValidUsername(label);
+    }
+    isContestedUsername(label) {
+        return wasm.WasmSdk.dpnsIsContestedUsername(label);
+    }
+    async isNameAvailable(label) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.dpnsIsNameAvailable(label);
+    }
+    async resolveName(name) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.dpnsResolveName(name);
+    }
+    async registerName(args) {
+        const { label, identityId, publicKeyId, privateKeyWif, onPreorder } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.dpnsRegisterName(label, identityId, publicKeyId, privateKeyWif, onPreorder ?? null);
+    }
+    async usernames(identityId, opts = {}) {
+        const { limit } = opts;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDpnsUsernames(identityId, limit ?? null);
+    }
+    async username(identityId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDpnsUsername(identityId);
+    }
+    async usernamesWithProof(identityId, opts = {}) {
+        const { limit } = opts;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDpnsUsernamesWithProofInfo(identityId, limit ?? null);
+    }
+    async usernameWithProof(identityId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDpnsUsernameWithProofInfo(identityId);
+    }
+    async getUsernameByName(username) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDpnsUsernameByName(username);
+    }
+    async getUsernameByNameWithProof(username) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getDpnsUsernameByNameWithProofInfo(username);
+    }
+}

package/dist/epoch/facade.d.ts

@@ -0,0 +1,39 @@
+import type { EvoSDK } from '../sdk.js';
+export declare class EpochFacade {
+    private sdk;
+    constructor(sdk: EvoSDK);
+    epochsInfo(params?: {
+        startEpoch?: number;
+        count?: number;
+        ascending?: boolean;
+    }): Promise<any>;
+    epochsInfoWithProof(params?: {
+        startEpoch?: number;
+        count?: number;
+        ascending?: boolean;
+    }): Promise<any>;
+    finalizedInfos(params?: {
+        startEpoch?: number;
+        count?: number;
+        ascending?: boolean;
+    }): Promise<any>;
+    finalizedInfosWithProof(params?: {
+        startEpoch?: number;
+        count?: number;
+        ascending?: boolean;
+    }): Promise<any>;
+    current(): Promise<any>;
+    currentWithProof(): Promise<any>;
+    evonodesProposedBlocksByIds(epoch: number, ids: string[]): Promise<any>;
+    evonodesProposedBlocksByIdsWithProof(epoch: number, ids: string[]): Promise<any>;
+    evonodesProposedBlocksByRange(epoch: number, opts?: {
+        limit?: number;
+        startAfter?: string;
+        orderAscending?: boolean;
+    }): Promise<any>;
+    evonodesProposedBlocksByRangeWithProof(epoch: number, opts?: {
+        limit?: number;
+        startAfter?: string;
+        orderAscending?: boolean;
+    }): Promise<any>;
+}

package/dist/epoch/facade.js

@@ -0,0 +1,43 @@
+export class EpochFacade {
+    constructor(sdk) { this.sdk = sdk; }
+    async epochsInfo(params = {}) {
+        const { startEpoch, count, ascending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getEpochsInfo(startEpoch ?? null, count ?? null, ascending ?? null);
+    }
+    async epochsInfoWithProof(params = {}) {
+        const { startEpoch, count, ascending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getEpochsInfoWithProofInfo(startEpoch ?? null, count ?? null, ascending ?? null);
+    }
+    async finalizedInfos(params = {}) {
+        const { startEpoch, count, ascending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getFinalizedEpochInfos(startEpoch ?? null, count ?? null, ascending ?? null);
+    }
+    async finalizedInfosWithProof(params = {}) {
+        const { startEpoch, count, ascending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getFinalizedEpochInfosWithProofInfo(startEpoch ?? null, count ?? null, ascending ?? null);
+    }
+    async current() { const w = await this.sdk.getWasmSdkConnected(); return w.getCurrentEpoch(); }
+    async currentWithProof() { const w = await this.sdk.getWasmSdkConnected(); return w.getCurrentEpochWithProofInfo(); }
+    async evonodesProposedBlocksByIds(epoch, ids) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getEvonodesProposedEpochBlocksByIds(epoch, ids);
+    }
+    async evonodesProposedBlocksByIdsWithProof(epoch, ids) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getEvonodesProposedEpochBlocksByIdsWithProofInfo(epoch, ids);
+    }
+    async evonodesProposedBlocksByRange(epoch, opts = {}) {
+        const { limit, startAfter, orderAscending } = opts;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getEvonodesProposedEpochBlocksByRange(epoch, limit ?? null, startAfter ?? null, orderAscending ?? null);
+    }
+    async evonodesProposedBlocksByRangeWithProof(epoch, opts = {}) {
+        const { limit, startAfter, orderAscending } = opts;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getEvonodesProposedEpochBlocksByRangeWithProofInfo(epoch, limit ?? null, startAfter ?? null, orderAscending ?? null);
+    }
+}

package/dist/group/facade.d.ts

@@ -0,0 +1,41 @@
+import type { EvoSDK } from '../sdk.js';
+export declare class GroupFacade {
+    private sdk;
+    constructor(sdk: EvoSDK);
+    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>;
+}

package/dist/group/facade.js

@@ -0,0 +1,23 @@
+export class GroupFacade {
+    constructor(sdk) { this.sdk = sdk; }
+    async contestedResources(params) {
+        const { documentTypeName, contractId, indexName, startAtValue, limit, orderAscending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getContestedResources(documentTypeName, contractId, indexName, startAtValue ?? null, limit ?? null, null, orderAscending ?? null);
+    }
+    async contestedResourcesWithProof(params) {
+        const { documentTypeName, contractId, indexName, startAtValue, limit, orderAscending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getContestedResourcesWithProofInfo(documentTypeName, contractId, indexName, startAtValue ?? null, limit ?? null, null, orderAscending ?? null);
+    }
+    async contestedResourceVotersForIdentity(params) {
+        const { contractId, documentTypeName, indexName, indexValues, contestantId, startAtVoterInfo, limit, orderAscending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getContestedResourceVotersForIdentity(contractId, documentTypeName, indexName, indexValues, contestantId, startAtVoterInfo ?? null, limit ?? null, orderAscending ?? null);
+    }
+    async contestedResourceVotersForIdentityWithProof(params) {
+        const { contractId, documentTypeName, indexName, indexValues, contestantId, startAtIdentifierInfo, count, orderAscending } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getContestedResourceVotersForIdentityWithProofInfo(contractId, documentTypeName, indexName, indexValues, contestantId, startAtIdentifierInfo ?? null, count ?? null, orderAscending ?? null);
+    }
+}

package/dist/identities/facade.d.ts

@@ -0,0 +1,48 @@
+import * as wasm from '../wasm.js';
+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>;
+    create(args: {
+        assetLockProof: unknown;
+        assetLockPrivateKeyWif: string;
+        publicKeys: unknown[];
+    }): Promise<any>;
+    topUp(args: {
+        identityId: string;
+        assetLockProof: unknown;
+        assetLockPrivateKeyWif: string;
+    }): Promise<any>;
+    creditTransfer(args: {
+        senderId: string;
+        recipientId: string;
+        amount: number | bigint | string;
+        privateKeyWif: string;
+        keyId?: number;
+    }): Promise<any>;
+    creditWithdrawal(args: {
+        identityId: string;
+        toAddress: string;
+        amount: number | bigint | string;
+        coreFeePerByte?: number;
+        privateKeyWif: string;
+        keyId?: number;
+    }): Promise<any>;
+    update(args: {
+        identityId: string;
+        addPublicKeys?: unknown[];
+        disablePublicKeyIds?: number[];
+        privateKeyWif: string;
+    }): Promise<any>;
+}

package/dist/identities/facade.js

@@ -0,0 +1,49 @@
+import { asJsonString } from '../util.js';
+export class IdentitiesFacade {
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async fetch(identityId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getIdentity(identityId);
+    }
+    async fetchWithProof(identityId) {
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getIdentityWithProofInfo(identityId);
+    }
+    async fetchUnproved(identityId) {
+        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);
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getIdentityKeys(identityId, keyRequestType, specificKeyIds ? Uint32Array.from(specificKeyIds) : null, mapJson ?? null, limit ?? null, offset ?? null);
+    }
+    async create(args) {
+        const { assetLockProof, assetLockPrivateKeyWif, publicKeys } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.identityCreate(asJsonString(assetLockProof), assetLockPrivateKeyWif, asJsonString(publicKeys));
+    }
+    async topUp(args) {
+        const { identityId, assetLockProof, assetLockPrivateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.identityTopUp(identityId, asJsonString(assetLockProof), assetLockPrivateKeyWif);
+    }
+    async creditTransfer(args) {
+        const { senderId, recipientId, amount, privateKeyWif, keyId } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.identityCreditTransfer(senderId, recipientId, BigInt(amount), privateKeyWif, keyId ?? null);
+    }
+    async creditWithdrawal(args) {
+        const { identityId, toAddress, amount, coreFeePerByte = 1, privateKeyWif, keyId } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.identityCreditWithdrawal(identityId, toAddress, BigInt(amount), coreFeePerByte ?? null, privateKeyWif, keyId ?? null);
+    }
+    async update(args) {
+        const { identityId, addPublicKeys, disablePublicKeyIds, privateKeyWif } = args;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.identityUpdate(identityId, addPublicKeys ? asJsonString(addPublicKeys) : null, disablePublicKeyIds ? Uint32Array.from(disablePublicKeyIds) : null, privateKeyWif);
+    }
+}

package/dist/protocol/facade.d.ts

@@ -0,0 +1,15 @@
+import type { EvoSDK } from '../sdk.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>;
+}

package/dist/protocol/facade.js

@@ -0,0 +1,15 @@
+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;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getProtocolVersionUpgradeVoteStatus(startProTxHash, count);
+    }
+    async versionUpgradeVoteStatusWithProof(params) {
+        const { startProTxHash, count } = params;
+        const w = await this.sdk.getWasmSdkConnected();
+        return w.getProtocolVersionUpgradeVoteStatusWithProofInfo(startProTxHash, count);
+    }
+}

package/dist/sdk.d.ts

@@ -0,0 +1,60 @@
+import * as wasm from './wasm.js';
+import { DocumentsFacade } from './documents/facade.js';
+import { IdentitiesFacade } from './identities/facade.js';
+import { ContractsFacade } from './contracts/facade.js';
+import { TokensFacade } from './tokens/facade.js';
+import { DpnsFacade } from './dpns/facade.js';
+import { EpochFacade } from './epoch/facade.js';
+import { ProtocolFacade } from './protocol/facade.js';
+import { SystemFacade } from './system/facade.js';
+import { GroupFacade } from './group/facade.js';
+import { VotingFacade } from './voting/facade.js';
+export interface ConnectionOptions {
+    version?: number;
+    proofs?: boolean;
+    logs?: string;
+    settings?: {
+        connectTimeoutMs?: number;
+        timeoutMs?: number;
+        retries?: number;
+        banFailedAddress?: boolean;
+    };
+}
+export interface EvoSDKOptions extends ConnectionOptions {
+    network?: 'testnet' | 'mainnet';
+    trusted?: boolean;
+}
+export declare class EvoSDK {
+    private wasmSdk?;
+    private options;
+    documents: DocumentsFacade;
+    identities: IdentitiesFacade;
+    contracts: ContractsFacade;
+    tokens: TokensFacade;
+    dpns: DpnsFacade;
+    epoch: EpochFacade;
+    protocol: ProtocolFacade;
+    system: SystemFacade;
+    group: GroupFacade;
+    voting: VotingFacade;
+    constructor(options?: EvoSDKOptions);
+    get wasm(): wasm.WasmSdk;
+    get isConnected(): boolean;
+    getWasmSdkConnected(): Promise<wasm.WasmSdk>;
+    connect(): Promise<void>;
+    static fromWasm(wasmSdk: wasm.WasmSdk): EvoSDK;
+    static testnet(options?: ConnectionOptions): EvoSDK;
+    static mainnet(options?: ConnectionOptions): EvoSDK;
+    static testnetTrusted(options?: ConnectionOptions): EvoSDK;
+    static mainnetTrusted(options?: ConnectionOptions): EvoSDK;
+}
+export { DocumentsFacade } from './documents/facade.js';
+export { IdentitiesFacade } from './identities/facade.js';
+export { ContractsFacade } from './contracts/facade.js';
+export { TokensFacade } from './tokens/facade.js';
+export { DpnsFacade } from './dpns/facade.js';
+export { EpochFacade } from './epoch/facade.js';
+export { ProtocolFacade } from './protocol/facade.js';
+export { SystemFacade } from './system/facade.js';
+export { GroupFacade } from './group/facade.js';
+export { VotingFacade } from './voting/facade.js';