@lfdecentralizedtrust/paladin-sdk 0.13.0-rc.1

package/build/interfaces/states.d.ts

@@ -0,0 +1,61 @@
+export interface ISchema {
+    id: string;
+    created: string;
+    domain: string;
+    type: SchemaType;
+    signature: string;
+    definition: object;
+    labels: string[];
+}
+export type SchemaType = "abi";
+export interface IStateBase {
+    id: string;
+    created: string;
+    domain: string;
+    schema: string;
+    contractAddress: string;
+    data: object;
+}
+export interface IStateEncoded {
+    id: string;
+    domain: string;
+    schema: string;
+    contractAddress: string;
+    data: string;
+}
+export interface IState extends IStateBase {
+    confirmed?: IStateConfirm;
+    spent?: IStateSpend;
+    locks?: IStateLock[];
+    nullifier?: IStateNullifier;
+}
+export interface IStateLabel {
+    domainName: string;
+    state: string;
+    label: string;
+    value: string;
+}
+export interface IStateInt64Label {
+    domainName: string;
+    state: string;
+    label: string;
+    value: number;
+}
+export interface IStateConfirm {
+    transaction: string;
+}
+export interface IStateSpend {
+    transaction: string;
+}
+type StateLockType = "create" | "read" | "spend";
+export interface IStateLock {
+    transaction: string;
+    type: StateLockType;
+}
+export interface IStateNullifier {
+    domain: string;
+    id: string;
+    spent?: IStateSpend;
+}
+export type StateStatus = "available" | "confirmed" | "unconfirmed" | "spent" | "all";
+export {};

package/build/interfaces/states.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/interfaces/transaction.d.ts

@@ -0,0 +1,159 @@
+import { BigNumberish, ethers } from "ethers";
+import { NotoUnlockPublicParams } from "../domains/noto";
+import { IStateBase } from "./states";
+export interface IBlock {
+    number: number;
+    hash: string;
+    timestamp: string;
+}
+export declare enum TransactionType {
+    PUBLIC = "public",
+    PRIVATE = "private"
+}
+export interface PublicTxOptions {
+    gas?: BigNumberish;
+    value?: BigNumberish;
+    maxPriorityFeePerGas?: BigNumberish;
+    maxFeePerGas?: BigNumberish;
+}
+export interface ITransactionBase {
+    type: TransactionType;
+    domain?: string;
+    function?: string;
+    from: string;
+    to?: string;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface ITransaction extends ITransactionBase {
+    id: string;
+    created: string;
+    abiReference: string;
+}
+export interface IPreparedTransaction {
+    id: string;
+    domain: string;
+    to: string;
+    transaction: ITransactionBase & {
+        abiReference: string;
+    };
+    states: {
+        spent?: IStateBase[];
+        read?: IStateBase[];
+        confirmed?: IStateBase[];
+        info?: IStateBase[];
+    };
+    metadata: any;
+}
+export interface ITransactionInput extends ITransactionBase {
+    abiReference?: string;
+    abi?: ethers.InterfaceAbi;
+    bytecode?: string;
+}
+export interface ITransactionCall extends ITransactionInput {
+}
+export interface ITransactionReceipt {
+    blockNumber: number;
+    id: string;
+    sequence: number;
+    success: boolean;
+    transactionHash: string;
+    source: string;
+    domain?: string;
+    contractAddress?: string;
+    states?: ITransactionStates;
+    domainReceipt?: IPenteDomainReceipt | INotoDomainReceipt;
+    failureMessage?: string;
+}
+export interface IPenteDomainReceipt {
+    receipt: {
+        from?: string;
+        to?: string;
+        contractAddress?: string;
+        logs?: IPenteLog[];
+    };
+}
+export interface IPenteLog {
+    address: string;
+    topics: string[];
+    data: string;
+}
+export interface INotoDomainReceipt {
+    states: {
+        inputs?: IReceiptState<INotoCoin>[];
+        outputs?: IReceiptState<INotoCoin>[];
+        readInputs?: IReceiptState<INotoCoin>[];
+        preparedOutputs?: IReceiptState<INotoCoin>[];
+        lockedInputs?: IReceiptState<INotoLockedCoin>[];
+        lockedOutputs?: IReceiptState<INotoLockedCoin>[];
+        readLockedInputs?: IReceiptState<INotoLockedCoin>[];
+        preparedLockedOutputs?: IReceiptState<INotoLockedCoin>[];
+    };
+    transfers?: {
+        from?: string;
+        to?: string;
+        amount: string;
+    }[];
+    lockInfo?: {
+        lockId: string;
+        delegate?: string;
+        unlockParams?: NotoUnlockPublicParams;
+        unlockCall?: string;
+    };
+    data?: string;
+}
+export interface IReceiptState<T> {
+    id: string;
+    data: T;
+}
+export interface INotoCoin {
+    salt: string;
+    owner: string;
+    amount: string;
+}
+export interface INotoLockedCoin {
+    lockId: string;
+    salt: string;
+    owner: string;
+    amount: string;
+}
+export interface ITransactionStates {
+    none?: boolean;
+    spent?: IStateBase[];
+    read?: IStateBase[];
+    confirmed?: IStateBase[];
+    info?: IStateBase[];
+    unavailable?: {
+        spent?: string[];
+        read?: string[];
+        confirmed?: string[];
+        info?: string[];
+    };
+}
+export declare enum TransactionType {
+    Private = "private",
+    Public = "public"
+}
+export interface IABIDecodedData {
+    signature: string;
+    definition: ethers.JsonFragment;
+    data: any;
+    summary: string;
+}
+export interface IStoredABI {
+    hash: string;
+    abi: ethers.InterfaceAbi;
+}
+export interface ITransactionReceiptListener {
+    name: string;
+    filters?: {
+        sequenceAbove?: number;
+        type?: TransactionType;
+        domain?: string;
+    };
+    options?: {
+        domainReceipts?: boolean;
+        incompleteStateReceiptBehavior?: "block_contract" | "process";
+    };
+}

package/build/interfaces/transaction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionType = void 0;
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["PUBLIC"] = "public";
+    TransactionType["PRIVATE"] = "private";
+})(TransactionType || (exports.TransactionType = TransactionType = {}));
+(function (TransactionType) {
+    TransactionType["Private"] = "private";
+    TransactionType["Public"] = "public";
+})(TransactionType || (exports.TransactionType = TransactionType = {}));

package/build/interfaces/transport.d.ts

@@ -0,0 +1,32 @@
+export interface IPeerInfo {
+    name: string;
+    stats: IPeerStats;
+    activated: string;
+    outboundTransport?: string;
+    outbound?: any;
+    outboundError?: any;
+}
+export interface IPeerStats {
+    sentMsgs: number;
+    receivedMsgs: number;
+    sentBytes: number;
+    receivedBytes: number;
+    lastSend?: string;
+    lastReceive?: string;
+    reliableHighestSent: number;
+    reliableAckBase: number;
+}
+export interface IReliableMessage {
+    sequence: number;
+    id: string;
+    created: string;
+    node: string;
+    messageType: string;
+    metadata: any;
+    ack?: IReliableMessageAck;
+}
+export interface IReliableMessageAck {
+    messageId: string;
+    time?: string;
+    error?: string;
+}

package/build/interfaces/transport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/interfaces/verifiers.d.ts

@@ -0,0 +1,6 @@
+export declare enum Verifiers {
+    ETH_ADDRESS = "eth_address",
+    ETH_ADDRESS_CHECKSUM = "eth_address_checksum",
+    HEX_ECDSA_PUBKEY_UNCOMPRESSED = "hex_ecdsa_pubkey_uncompressed",
+    HEX_ECDSA_PUBKEY_UNCOMPRESSED_0X = "hex_ecdsa_pubkey_uncompressed_0x"
+}

package/build/interfaces/verifiers.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Verifiers = void 0;
+var Verifiers;
+(function (Verifiers) {
+    Verifiers["ETH_ADDRESS"] = "eth_address";
+    Verifiers["ETH_ADDRESS_CHECKSUM"] = "eth_address_checksum";
+    Verifiers["HEX_ECDSA_PUBKEY_UNCOMPRESSED"] = "hex_ecdsa_pubkey_uncompressed";
+    Verifiers["HEX_ECDSA_PUBKEY_UNCOMPRESSED_0X"] = "hex_ecdsa_pubkey_uncompressed_0x";
+})(Verifiers || (exports.Verifiers = Verifiers = {}));

package/build/interfaces/websocket.d.ts

@@ -0,0 +1,57 @@
+import * as http from "http";
+import WebSocket from "ws";
+import { IEventWithData } from "./blockindex";
+import { Logger } from "./logger";
+import { ITransactionReceipt } from "./transaction";
+import { IPrivacyGroupMessage } from "./privacygroups";
+export interface WebSocketSender {
+    send: (json: object) => void;
+    ack: (subscription: string) => void;
+}
+export interface WebSocketConnectCallback {
+    (sender: WebSocketSender): void | Promise<void>;
+}
+export interface WebSocketEventCallback<TEvent> {
+    (sender: WebSocketSender, event: TEvent): void | Promise<void>;
+}
+export interface WebSocketClientOptions<TMessageTypes extends string> {
+    url: string;
+    username?: string;
+    password?: string;
+    subscriptions?: WebSocketSubscription<TMessageTypes>[];
+    logger?: Logger;
+    heartbeatInterval?: number;
+    reconnectDelay?: number;
+    afterConnect?: WebSocketConnectCallback;
+    socketOptions?: WebSocket.ClientOptions | http.ClientRequestArgs;
+}
+export interface WebSocketSubscription<TMessageTypes extends string> {
+    type: TMessageTypes;
+    name: string;
+}
+export interface WebSocketEvent {
+    method: "ptx_subscription" | undefined;
+    params: {
+        subscription: string;
+        result: TransactionReceiptBatch | TransactionEventBatch;
+    };
+}
+export interface TransactionReceiptBatch {
+    batchId: number;
+    receipts: ITransactionReceipt[];
+}
+export interface TransactionEventBatch {
+    batchId: number;
+    events: IEventWithData[];
+}
+export interface PrivacyGroupWebSocketEvent {
+    method: "pgroup_subscription" | undefined;
+    params: {
+        subscription: string;
+        result: IPrivacyGroupMessageBatch;
+    };
+}
+export interface IPrivacyGroupMessageBatch {
+    batchId: number;
+    messages: IPrivacyGroupMessage[];
+}

package/build/interfaces/websocket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/paladin.d.ts

@@ -0,0 +1,265 @@
+import { AxiosInstance } from "axios";
+import { ethers, InterfaceAbi } from "ethers";
+import { ActiveFilter, Algorithms, IABIDecodedData, IBlockchainEventListener, IEthAddress, IEventWithData, IKeyMappingAndVerifier, IKeyQueryEntry, INotoDomainReceipt, IPenteDomainReceipt, IPreparedTransaction, IPrivacyGroup, IPrivacyGroupEVMCall, IPrivacyGroupEVMTXInput, IPrivacyGroupInput, IPrivacyGroupMessageInput, IPrivacyGroupMessageListener, IQuery, IRegistryEntry, IRegistryEntryWithProperties, IRegistryProperty, ISchema, IState, IStoredABI, ITransaction, ITransactionCall, ITransactionInput, ITransactionReceipt, ITransactionReceiptListener, ITransactionStates, IWalletInfo, PaladinConfig, StateStatus, Verifiers } from "./interfaces";
+import { PaladinVerifier } from "./verifier";
+export default class PaladinClient {
+    protected http: AxiosInstance;
+    private logger;
+    private onError;
+    constructor(options: PaladinConfig);
+    getHttpInstance(): AxiosInstance;
+    protected defaultHeaders(): {
+        Accept: string;
+        "Content-Type": string;
+    };
+    protected defaultPayload(): {
+        jsonrpc: string;
+        id: number;
+    };
+    getVerifiers(...lookups: string[]): PaladinVerifier[];
+    parseAxiosErrorMessage(err: any): any;
+    private post;
+    pollForReceipt(txID: string, waitMs: number, full?: boolean): Promise<ITransactionReceipt | undefined>;
+    pollForPreparedTransaction(txID: string, waitMs: number): Promise<IPreparedTransaction | undefined>;
+    /**
+     * @deprecated Use ptx.prepareTransaction instead
+     */
+    prepareTransaction(transaction: ITransactionInput): Promise<string>;
+    /**
+     * @deprecated Use ptx.sendTransaction instead
+     */
+    sendTransaction(transaction: ITransactionInput): Promise<string>;
+    /**
+     * @deprecated Use ptx.call instead
+     */
+    call(transaction: ITransactionCall): Promise<any>;
+    /**
+     * @deprecated Use ptx.queryTransactions instead
+     */
+    queryTransactions(query: IQuery): Promise<ITransaction[]>;
+    /**
+     * @deprecated Use ptx.getTransaction or ptx.getTransactionFull instead
+     */
+    getTransaction(txID: string, full?: boolean): Promise<ITransaction | undefined>;
+    /**
+     * @deprecated Use ptx.getPreparedTransaction instead
+     */
+    getPreparedTransaction(txID: string): Promise<IPreparedTransaction | undefined>;
+    /**
+     * @deprecated Use ptx.queryTransactionReceipts instead
+     */
+    queryTransactionReceipts(query: IQuery): Promise<ITransactionReceipt[]>;
+    /**
+     * @deprecated Use ptx.getTransactionReceipt or ptx.getTransactionReceiptFull instead
+     */
+    getTransactionReceipt(txID: string, full?: boolean): Promise<ITransactionReceipt | undefined>;
+    /**
+     * @deprecated Use ptx.getStateReceipt instead
+     */
+    getStateReceipt(txID: string): Promise<ITransactionStates | undefined>;
+    /**
+     * @deprecated Use ptx.getDomainReceipt instead
+     */
+    getDomainReceipt(domain: string, txID: string): Promise<IPenteDomainReceipt | INotoDomainReceipt | undefined>;
+    /**
+     * @deprecated Use ptx.resolveVerifier instead
+     */
+    resolveVerifier(lookup: string, algorithm: Algorithms | string, verifierType: Verifiers | string): Promise<string>;
+    /**
+     * @deprecated Use ptx.storeABI instead
+     */
+    storeABI(abi: ethers.InterfaceAbi): Promise<void>;
+    /**
+     * @deprecated Use ptx.getStoredABI instead
+     */
+    getStoredABI(hash: string): Promise<IStoredABI>;
+    /**
+     * @deprecated Use ptx.decodeCall instead
+     */
+    decodeCall(callData: string, dataFormat: string): Promise<IABIDecodedData>;
+    /**
+     * @deprecated Use ptx.decodeEvent instead
+     */
+    decodeEvent(topics: string[], data: string): Promise<IABIDecodedData | undefined>;
+    /**
+     * @deprecated Use ptx.decodeError instead
+     */
+    decodeError(revertError: string, dataFormat: string): Promise<IABIDecodedData>;
+    /**
+     * @deprecated Use bidx.decodeTransactionEvents instead
+     */
+    decodeTransactionEvents(transactionHash: string, abi: InterfaceAbi, resultFormat: string): Promise<IEventWithData[]>;
+    /**
+     * @deprecated Use pstate.listSchemas instead
+     */
+    listSchemas(domain: string): Promise<ISchema[]>;
+    /**
+     * @deprecated Use pstate.queryStates instead
+     */
+    queryStates(domain: string, schema: string, query: IQuery, status: StateStatus): Promise<IState[]>;
+    /**
+     * @deprecated Use pstate.queryContractStates instead
+     */
+    queryContractStates(domain: string, contractAddress: string, schema: string, query: IQuery, status: StateStatus): Promise<IState[]>;
+    /**
+     * @deprecated Use pgroup.createGroup instead
+     */
+    createPrivacyGroup(pgroup: IPrivacyGroupInput): Promise<IPrivacyGroup>;
+    /**
+     * @deprecated Use pgroup.getGroupById instead
+     */
+    getPrivacyGroupById(domainName: string, id: string): Promise<IPrivacyGroup>;
+    /**
+     * @deprecated Use pgroup.getGroupByAddress instead
+     */
+    getPrivacyGroupByAddress(address: string): Promise<IPrivacyGroup>;
+    /**
+     * @deprecated Use pgroup.sendTransaction instead
+     */
+    sendPrivacyGroupTransaction(txi: IPrivacyGroupEVMTXInput): Promise<string>;
+    /**
+     * @deprecated Use pgroup.call instead
+     */
+    callPrivacyGroup(txi: IPrivacyGroupEVMCall): Promise<any>;
+    /**
+     * @deprecated Use ptx.createReceiptListener instead
+     */
+    createReceiptListener(listener: ITransactionReceiptListener): Promise<boolean>;
+    /**
+     * @deprecated Use ptx.deleteReceiptListener instead
+     */
+    deleteReceiptListener(name: string): Promise<boolean>;
+    /**
+     * @deprecated Use ptx.getReceiptListener instead
+     */
+    getReceiptListener(name: string): Promise<ITransactionReceiptListener | undefined>;
+    /**
+     * @deprecated Use ptx.createBlockchainEventListener instead
+     */
+    createBlockchainEventListener(listener: IBlockchainEventListener): Promise<boolean>;
+    /**
+     * @deprecated Use ptx.deleteBlockchainEventListener instead
+     */
+    deleteBlockchainEventListener(name: string): Promise<boolean>;
+    /**
+     * @deprecated Use ptx.getBlockchainEventListener instead
+     */
+    getBlockchainEventListener(name: string): Promise<IBlockchainEventListener | undefined>;
+    keymgr: {
+        wallets: () => Promise<IWalletInfo[]>;
+        resolveKey: (identifier: string, algorithm: string, verifierType: string) => Promise<IKeyMappingAndVerifier>;
+        resolveEthAddress: (identifier: string) => Promise<IEthAddress>;
+        reverseKeyLookup: (algorithm: string, verifierType: string, verifier: string) => Promise<IKeyMappingAndVerifier>;
+        queryKeys: (query: IQuery) => Promise<IKeyQueryEntry[]>;
+    };
+    ptx: {
+        sendTransaction: (transaction: ITransactionInput) => Promise<string>;
+        sendTransactions: (transactions: ITransactionInput[]) => Promise<string[]>;
+        prepareTransaction: (transaction: ITransactionInput) => Promise<string>;
+        prepareTransactions: (transactions: ITransactionInput[]) => Promise<string[]>;
+        updateTransaction: (id: string, transaction: ITransactionInput) => Promise<string>;
+        call: (transaction: ITransactionCall) => Promise<any>;
+        getTransaction: (txID: string) => Promise<ITransaction | undefined>;
+        getTransactionFull: (txID: string) => Promise<ITransaction | undefined>;
+        getTransactionByIdempotencyKey: (idempotencyKey: string) => Promise<ITransaction | undefined>;
+        queryTransactions: (query: IQuery) => Promise<ITransaction[]>;
+        queryTransactionsFull: (query: IQuery) => Promise<ITransaction[]>;
+        queryPendingTransactions: (query: IQuery, full?: boolean) => Promise<ITransaction[]>;
+        getTransactionReceipt: (txID: string) => Promise<ITransactionReceipt | undefined>;
+        getTransactionReceiptFull: (txID: string) => Promise<ITransactionReceipt | undefined>;
+        getDomainReceipt: (domain: string, txID: string) => Promise<IPenteDomainReceipt | INotoDomainReceipt | undefined>;
+        getStateReceipt: (txID: string) => Promise<ITransactionStates | undefined>;
+        queryTransactionReceipts: (query: IQuery) => Promise<ITransactionReceipt[]>;
+        getTransactionDependencies: (txID: string) => Promise<string[] | undefined>;
+        queryPublicTransactions: (query: IQuery) => Promise<any[]>;
+        queryPendingPublicTransactions: (query: IQuery) => Promise<any[]>;
+        getPublicTransactionByNonce: (from: string, nonce: number) => Promise<any>;
+        getPublicTransactionByHash: (hash: string) => Promise<any>;
+        getPreparedTransaction: (txID: string) => Promise<IPreparedTransaction | undefined>;
+        queryPreparedTransactions: (query: IQuery) => Promise<IPreparedTransaction[]>;
+        storeABI: (abi: ethers.InterfaceAbi) => Promise<void>;
+        getStoredABI: (hash: string) => Promise<IStoredABI>;
+        queryStoredABIs: (query: IQuery) => Promise<IStoredABI[]>;
+        decodeCall: (callData: string, dataFormat: string) => Promise<IABIDecodedData>;
+        decodeEvent: (topics: string[], data: string) => Promise<IABIDecodedData | undefined>;
+        decodeError: (revertError: string, dataFormat: string) => Promise<IABIDecodedData>;
+        resolveVerifier: (lookup: string, algorithm: Algorithms | string, verifierType: Verifiers | string) => Promise<string>;
+        createReceiptListener: (listener: ITransactionReceiptListener) => Promise<boolean>;
+        queryReceiptListeners: (query: IQuery) => Promise<ITransactionReceiptListener[]>;
+        getReceiptListener: (name: string) => Promise<ITransactionReceiptListener | undefined>;
+        startReceiptListener: (name: string) => Promise<boolean>;
+        stopReceiptListener: (name: string) => Promise<boolean>;
+        deleteReceiptListener: (name: string) => Promise<boolean>;
+        createBlockchainEventListener: (listener: IBlockchainEventListener) => Promise<boolean>;
+        queryBlockchainEventListeners: (query: IQuery) => Promise<IBlockchainEventListener[]>;
+        getBlockchainEventListener: (name: string) => Promise<IBlockchainEventListener | undefined>;
+        startBlockchainEventListener: (name: string) => Promise<boolean>;
+        stopBlockchainEventListener: (name: string) => Promise<boolean>;
+        deleteBlockchainEventListener: (name: string) => Promise<boolean>;
+        getBlockchainEventListenerStatus: (name: string) => Promise<any>;
+    };
+    pstate: {
+        listSchemas: (domain: string) => Promise<ISchema[]>;
+        getSchemaById: (domain: string, schemaId: string) => Promise<ISchema | undefined>;
+        storeState: (domain: string, contractAddress: string, schema: string, data: any) => Promise<IState>;
+        queryStates: (domain: string, schema: string, query: IQuery, status: StateStatus) => Promise<IState[]>;
+        queryContractStates: (domain: string, contractAddress: string, schema: string, query: IQuery, status: StateStatus) => Promise<IState[]>;
+        queryNullifiers: (domain: string, schema: string, query: IQuery, status: StateStatus) => Promise<IState[]>;
+        queryContractNullifiers: (domain: string, contractAddress: string, schema: string, query: IQuery, status: StateStatus) => Promise<IState[]>;
+    };
+    pgroup: {
+        createGroup: (pgroup: IPrivacyGroupInput) => Promise<IPrivacyGroup>;
+        getGroupById: (domainName: string, id: string) => Promise<IPrivacyGroup>;
+        getGroupByAddress: (address: string) => Promise<IPrivacyGroup>;
+        queryGroups: (query: IQuery) => Promise<IPrivacyGroup[]>;
+        queryGroupsWithMember: (member: string, query: IQuery) => Promise<IPrivacyGroup[]>;
+        sendTransaction: (txi: IPrivacyGroupEVMTXInput) => Promise<string>;
+        call: (txi: IPrivacyGroupEVMCall) => Promise<any>;
+        sendMessage: (msg: IPrivacyGroupMessageInput) => Promise<string>;
+        getMessageById: (id: string) => Promise<any>;
+        queryMessages: (query: IQuery) => Promise<any[]>;
+        createMessageListener: (listener: IPrivacyGroupMessageListener) => Promise<boolean>;
+        queryMessageListeners: (query: IQuery) => Promise<IPrivacyGroupMessageListener[]>;
+        getMessageListener: (name: string) => Promise<IPrivacyGroupMessageListener | undefined>;
+        startMessageListener: (name: string) => Promise<boolean>;
+        stopMessageListener: (name: string) => Promise<boolean>;
+        deleteMessageListener: (name: string) => Promise<boolean>;
+    };
+    transport: {
+        nodeName: () => Promise<string>;
+        localTransports: () => Promise<string[]>;
+        localTransportDetails: (transportName: string) => Promise<string>;
+        peers: () => Promise<any[]>;
+        peerInfo: (nodeName: string) => Promise<any>;
+        queryReliableMessages: (query: IQuery) => Promise<any[]>;
+        queryReliableMessageAcks: (query: IQuery) => Promise<any[]>;
+    };
+    domain: {
+        listDomains: () => Promise<string[]>;
+        getDomain: (name: string) => Promise<any>;
+        getDomainByAddress: (address: string) => Promise<any>;
+        querySmartContracts: (query: IQuery) => Promise<any[]>;
+        getSmartContractByAddress: (address: string) => Promise<any>;
+    };
+    bidx: {
+        getBlockByNumber: (number: number) => Promise<any>;
+        getTransactionByHash: (hash: string) => Promise<any>;
+        getTransactionByNonce: (from: string, nonce: number) => Promise<any>;
+        getBlockTransactionsByNumber: (blockNumber: number) => Promise<any[]>;
+        getTransactionEventsByHash: (hash: string) => Promise<any[]>;
+        queryIndexedBlocks: (query: IQuery) => Promise<any[]>;
+        queryIndexedTransactions: (query: IQuery) => Promise<any[]>;
+        queryIndexedEvents: (query: IQuery) => Promise<any[]>;
+        getConfirmedBlockHeight: () => Promise<number>;
+        decodeTransactionEvents: (transactionHash: string, abi: InterfaceAbi, resultFormat: string) => Promise<IEventWithData[]>;
+    };
+    debug: {
+        getTransactionStatus: (txID: string) => Promise<any>;
+    };
+    reg: {
+        registries: () => Promise<string[]>;
+        queryEntries: (registryName: string, query: IQuery, activeFilter: ActiveFilter) => Promise<IRegistryEntry[]>;
+        queryEntriesWithProps: (registryName: string, query: IQuery, activeFilter: ActiveFilter) => Promise<IRegistryEntryWithProperties[]>;
+        getEntryProperties: (registryName: string, entryId: string, activeFilter: ActiveFilter) => Promise<IRegistryProperty[]>;
+    };
+}