@xelis/sdk 0.3.4 → 0.5.0

package/daemon/rpc.d.ts

@@ -1,34 +1,32 @@
-import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetLastBalanceResult, P2PStatusResult, RPCMethod, RPCResponse, Transaction, GetLastBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from './types';
-declare class RPC {
-    endpoint: string;
-    constructor(endpoint: string);
-    post<T>(method: RPCMethod, params?: any): Promise<RPCResponse<T>>;
-    getVersion(): Promise<RPCResponse<string>>;
-    getInfo(): Promise<RPCResponse<GetInfoResult>>;
-    getHeight(): Promise<RPCResponse<number>>;
-    getTopoHeight(): Promise<RPCResponse<number>>;
-    getStableHeight(): Promise<RPCResponse<number>>;
-    getBlockTemplate(address: string): Promise<RPCResponse<string>>;
-    getBlockAtTopoHeight(params: GetBlockAtTopoHeightParams): Promise<RPCResponse<Block>>;
-    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<RPCResponse<Block[]>>;
-    getBlockByHash(params: GetBlockByHashParams): Promise<RPCResponse<Block>>;
-    getTopBlock(params: GetTopBlockParams): Promise<RPCResponse<Block>>;
-    getNonce(address: string): Promise<RPCResponse<number>>;
-    getLastBalance(params: GetLastBalanceParams): Promise<RPCResponse<GetLastBalanceResult>>;
-    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<RPCResponse<Balance>>;
-    getAssets(): Promise<RPCResponse<string[]>>;
-    countTransactions(): Promise<RPCResponse<number>>;
-    countAssets(): Promise<RPCResponse<number>>;
-    getTips(): Promise<RPCResponse<string[]>>;
-    p2pStatus(): Promise<RPCResponse<P2PStatusResult>>;
-    getDAGOrder(params: TopoHeightRangeParams): Promise<RPCResponse<string[]>>;
-    getMemPool(): Promise<RPCResponse<Transaction[]>>;
-    getTransaction(hash: string): Promise<RPCResponse<Transaction>>;
-    getTransactions(txHashes: string[]): Promise<RPCResponse<Transaction[]>>;
-    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<RPCResponse<Block[]>>;
-    getBlocksRangeByHeight(params: HeightRangeParams): Promise<RPCResponse<Block[]>>;
-    getAccounts(params: GetAccountsParams): Promise<RPCResponse<string[]>>;
-    submitBlock(blockTemplate: string): Promise<RPCResponse<boolean>>;
-    submitTransaction(hexData: string): Promise<RPCResponse<boolean>>;
+import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetLastBalanceResult, P2PStatusResult, Transaction, GetLastBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from './types';
+import { RPC as BaseRPC } from '../lib/rpc';
+declare class RPC extends BaseRPC {
+    getVersion(): Promise<import("../lib/types").RPCResponse<string>>;
+    getInfo(): Promise<import("../lib/types").RPCResponse<GetInfoResult>>;
+    getHeight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getTopoHeight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getStableHeight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getBlockTemplate(address: string): Promise<import("../lib/types").RPCResponse<string>>;
+    getBlockAtTopoHeight(params: GetBlockAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<Block>>;
+    getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getBlockByHash(params: GetBlockByHashParams): Promise<import("../lib/types").RPCResponse<Block>>;
+    getTopBlock(params: GetTopBlockParams): Promise<import("../lib/types").RPCResponse<Block>>;
+    getNonce(address: string): Promise<import("../lib/types").RPCResponse<number>>;
+    getLastBalance(params: GetLastBalanceParams): Promise<import("../lib/types").RPCResponse<GetLastBalanceResult>>;
+    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<Balance>>;
+    getAssets(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    countTransactions(): Promise<import("../lib/types").RPCResponse<number>>;
+    countAssets(): Promise<import("../lib/types").RPCResponse<number>>;
+    getTips(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    p2pStatus(): Promise<import("../lib/types").RPCResponse<P2PStatusResult>>;
+    getDAGOrder(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getMemPool(): Promise<import("../lib/types").RPCResponse<Transaction[]>>;
+    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<Transaction>>;
+    getTransactions(txHashes: string[]): Promise<import("../lib/types").RPCResponse<Transaction[]>>;
+    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getBlocksRangeByHeight(params: HeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
+    getAccounts(params: GetAccountsParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    submitBlock(blockTemplate: string): Promise<import("../lib/types").RPCResponse<boolean>>;
+    submitTransaction(hexData: string): Promise<import("../lib/types").RPCResponse<boolean>>;
 }
 export default RPC;

package/daemon/rpc.js

@@ -1,27 +1,6 @@
 import { RPCMethod } from './types';
-class RPC {
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-    }
-    async post(method, params) {
-        try {
-            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
-            const res = await fetch(this.endpoint, { method: `POST`, body });
-            if (res.ok) {
-                const data = await res.json();
-                if (data.error) {
-                    return Promise.reject(new Error(data.error.message));
-                }
-                return Promise.resolve(data);
-            }
-            else {
-                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
-            }
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
-    }
+import { RPC as BaseRPC } from '../lib/rpc';
+class RPC extends BaseRPC {
     getVersion() {
         return this.post(RPCMethod.GetVersion);
     }

package/daemon/types.d.ts

@@ -1,18 +1,3 @@
-export interface RPCRequest {
-    id: number;
-    jsonrpc: string;
-    method: string;
-    params: string;
-}
-export interface RPCError {
-    code: number;
-    message: string;
-}
-export interface RPCResponse<T> {
-    id: number;
-    result: T;
-    error?: RPCError;
-}
 export interface GetInfoResult {
     block_time_target: number;
     difficulty: number;

package/daemon/websocket.d.ts

@@ -1,28 +1,12 @@
-/// <reference types="node" />
 import { MessageEvent } from 'ws';
-import WebSocket from 'isomorphic-ws';
-import { Block, RPCResponse, GetInfoResult, RPCEvent, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetLastBalanceResult, HeightRangeParams, BlockOrdered, GetLastBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from './types';
-declare class WS {
-    endpoint: string;
-    socket?: WebSocket;
-    timeout: number;
-    connected: boolean;
-    unsubscribeSuspense: number;
-    private events;
-    constructor();
-    connect(endpoint: string): Promise<unknown>;
-    close(code?: number | undefined, data?: string | Buffer | undefined): void;
-    onClose(cb: (event: WebSocket.CloseEvent) => void): void;
-    onError(cb: (err: WebSocket.ErrorEvent) => void): void;
-    private clearEvent;
-    closeAllListens(event: RPCEvent): Promise<void>;
-    listenEvent<T>(event: RPCEvent, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
+import { Block, GetInfoResult, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetLastBalanceResult, HeightRangeParams, BlockOrdered, GetLastBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from './types';
+import { WS as BaseWS } from '../lib/websocket';
+declare class WS extends BaseWS {
     onNewBlock(onData: (msgEvent: MessageEvent, data?: Block & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onTransactionAddedInMempool(onData: (msgEvent: MessageEvent, data?: Transaction & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onTransactionExecuted(onData: (msgEvent: MessageEvent, data?: Transaction & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onBlockOrdered(onData: (msgEvent: MessageEvent, data?: BlockOrdered & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
-    call<T>(method: string, params?: any): Promise<RPCResponse<T>>;
-    dataCall<T>(method: string, params?: any): Promise<T>;
+    getVersion(): Promise<string>;
     getInfo(): Promise<GetInfoResult>;
     getHeight(): Promise<number>;
     getTopoHeight(): Promise<number>;

package/daemon/websocket.js

@@ -1,140 +1,6 @@
-import WebSocket from 'isomorphic-ws';
-import to from 'await-to-js';
 import { RPCEvent, RPCMethod } from './types';
-function createRequestMethod(method, params) {
-    const id = Math.floor(Date.now() * Math.random());
-    const request = { id: id, jsonrpc: `2.0`, method };
-    if (params)
-        request.params = params;
-    const data = JSON.stringify(request);
-    return { data, id };
-}
-class WS {
-    constructor() {
-        this.endpoint = "";
-        this.timeout = 3000;
-        this.connected = false;
-        this.events = {};
-        this.unsubscribeSuspense = 1000;
-    }
-    connect(endpoint) {
-        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
-            this.socket.close();
-        }
-        return new Promise((resolve, reject) => {
-            this.socket = new WebSocket(endpoint);
-            this.endpoint = endpoint;
-            this.socket.addEventListener(`open`, (event) => {
-                this.connected = true;
-                resolve(event);
-            });
-            this.socket.addEventListener(`close`, () => {
-                this.connected = false;
-                reject();
-            });
-            this.socket.addEventListener(`error`, (err) => {
-                this.connected = false;
-                reject(err);
-            });
-        });
-    }
-    close(code, data) {
-        this.socket && this.socket.close(code, data);
-    }
-    onClose(cb) {
-        if (!this.socket)
-            return;
-        this.socket.addEventListener(`close`, (event) => {
-            cb(event);
-        });
-    }
-    onError(cb) {
-        if (!this.socket)
-            return;
-        this.socket.addEventListener(`error`, (err) => {
-            cb(err);
-        });
-    }
-    clearEvent(event) {
-        this.events[event].listeners.forEach(listener => {
-            this.socket && this.socket.removeEventListener(`message`, listener);
-        });
-        Reflect.deleteProperty(this.events, event);
-    }
-    async closeAllListens(event) {
-        if (this.events[event]) {
-            const [err, _] = await to(this.call(`unsubscribe`, { notify: event }));
-            if (err)
-                return Promise.reject(err);
-            this.clearEvent(event);
-        }
-        return Promise.resolve();
-    }
-    async listenEvent(event, onData) {
-        const onMessage = (msgEvent) => {
-            if (this.events[event]) {
-                const { id } = this.events[event];
-                if (typeof msgEvent.data === `string`) {
-                    try {
-                        const data = JSON.parse(msgEvent.data);
-                        if (data.id === id) {
-                            if (data.error) {
-                                onData(msgEvent, undefined, new Error(data.error.message));
-                            }
-                            else {
-                                onData(msgEvent, data.result, undefined);
-                            }
-                        }
-                    }
-                    catch (_a) {
-                        // can't parse json -- do nothing
-                    }
-                }
-            }
-        };
-        if (this.events[event]) {
-            const { unsubscribeTimeoutId } = this.events[event];
-            if (unsubscribeTimeoutId) {
-                // clear timeout to unsubscribe 
-                // because we got a new registered event and want to cancel the pending unsubscribe grace period
-                clearTimeout(unsubscribeTimeoutId);
-            }
-            this.events[event].listeners.push(onMessage);
-        }
-        else {
-            // important if multiple listenEvent are called without await atleast we store listener before getting id
-            this.events[event] = { listeners: [onMessage] };
-            const [err, res] = await to(this.call(`subscribe`, { notify: event }));
-            if (err) {
-                this.clearEvent(event);
-                return Promise.reject(err);
-            }
-            this.events[event].id = res.id;
-        }
-        this.socket && this.socket.addEventListener(`message`, onMessage);
-        const closeListen = () => {
-            const eventData = this.events[event];
-            if (eventData) {
-                const listeners = eventData.listeners;
-                for (let i = 0; i < listeners.length; i++) {
-                    if (listeners[i] === onMessage) {
-                        listeners.splice(i, 1);
-                        break;
-                    }
-                }
-                if (listeners.length === 0) {
-                    this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
-                        // no more listener so we unsubscribe from daemon websocket
-                        this.call(`unsubscribe`, { notify: event });
-                        Reflect.deleteProperty(this.events, event);
-                    }, this.unsubscribeSuspense);
-                }
-            }
-            this.socket && this.socket.removeEventListener(`message`, onMessage);
-            return Promise.resolve();
-        };
-        return Promise.resolve(closeListen);
-    }
+import { WS as BaseWS } from '../lib/websocket';
+class WS extends BaseWS {
     onNewBlock(onData) {
         return this.listenEvent(RPCEvent.NewBlock, onData);
     }
@@ -147,39 +13,8 @@ class WS {
     onBlockOrdered(onData) {
         return this.listenEvent(RPCEvent.BlockOrdered, onData);
     }
-    call(method, params) {
-        return new Promise((resolve, reject) => {
-            const { data, id } = createRequestMethod(method, params);
-            let timeoutId = null;
-            const onMessage = (msgEvent) => {
-                if (typeof msgEvent.data === `string`) {
-                    const data = JSON.parse(msgEvent.data);
-                    if (data.id === id) {
-                        clearTimeout(timeoutId);
-                        this.socket && this.socket.removeEventListener(`message`, onMessage);
-                        if (data.error)
-                            return reject(new Error(data.error.message));
-                        else
-                            resolve(data);
-                    }
-                }
-            };
-            // make sure you listen before sending data
-            this.socket && this.socket.addEventListener(`message`, onMessage); // we don't use { once: true } option because of timeout feature
-            timeoutId = setTimeout(() => {
-                this.socket && this.socket.removeEventListener(`message`, onMessage);
-                reject(new Error(`timeout`));
-            }, this.timeout);
-            this.socket && this.socket.send(data);
-        });
-    }
-    dataCall(method, params) {
-        return new Promise(async (resolve, reject) => {
-            const [err, res] = await to(this.call(method, params));
-            if (err)
-                return reject(err);
-            return resolve(res.result);
-        });
+    getVersion() {
+        return this.dataCall(RPCMethod.GetVersion);
     }
     getInfo() {
         return this.dataCall(RPCMethod.GetInfo);

package/lib/rpc.d.ts

@@ -0,0 +1,6 @@
+import { RPCResponse } from './types';
+export declare class RPC {
+    endpoint: string;
+    constructor(endpoint: string);
+    post<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+}

package/lib/rpc.js

@@ -0,0 +1,24 @@
+export class RPC {
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    async post(method, params) {
+        try {
+            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
+            const res = await fetch(this.endpoint, { method: `POST`, body });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.error) {
+                    return Promise.reject(new Error(data.error.message));
+                }
+                return Promise.resolve(data);
+            }
+            else {
+                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
+            }
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,15 @@
+export interface RPCRequest {
+    id: number;
+    jsonrpc: string;
+    method: string;
+    params: string;
+}
+export interface RPCError {
+    code: number;
+    message: string;
+}
+export interface RPCResponse<T> {
+    id: number;
+    result: T;
+    error?: RPCError;
+}

package/lib/types.js

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

package/lib/websocket.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { MessageEvent } from 'ws';
+import WebSocket from 'isomorphic-ws';
+import { RPCResponse } from './types';
+export declare class WS {
+    endpoint: string;
+    socket?: WebSocket;
+    timeout: number;
+    connected: boolean;
+    unsubscribeSuspense: number;
+    private events;
+    constructor();
+    connect(endpoint: string): Promise<unknown>;
+    close(code?: number | undefined, data?: string | Buffer | undefined): void;
+    onClose(cb: (event: WebSocket.CloseEvent) => void): void;
+    onError(cb: (err: WebSocket.ErrorEvent) => void): void;
+    private clearEvent;
+    closeAllListens(event: string): Promise<void>;
+    listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
+    call<T>(method: string, params?: any): Promise<RPCResponse<T>>;
+    dataCall<T>(method: string, params?: any): Promise<T>;
+}

package/lib/websocket.js

@@ -0,0 +1,171 @@
+import WebSocket from 'isomorphic-ws';
+import to from 'await-to-js';
+function createRequestMethod(method, params) {
+    const id = Math.floor(Date.now() * Math.random());
+    const request = { id: id, jsonrpc: `2.0`, method };
+    if (params)
+        request.params = params;
+    const data = JSON.stringify(request);
+    return { data, id };
+}
+export class WS {
+    constructor() {
+        this.endpoint = "";
+        this.timeout = 3000;
+        this.connected = false;
+        this.events = {};
+        this.unsubscribeSuspense = 1000;
+    }
+    connect(endpoint) {
+        if (this.socket && this.socket.readyState !== WebSocket.CLOSED) {
+            this.socket.close();
+        }
+        return new Promise((resolve, reject) => {
+            this.socket = new WebSocket(endpoint);
+            this.endpoint = endpoint;
+            this.socket.addEventListener(`open`, (event) => {
+                this.connected = true;
+                resolve(event);
+            });
+            this.socket.addEventListener(`close`, () => {
+                this.connected = false;
+                reject();
+            });
+            this.socket.addEventListener(`error`, (err) => {
+                this.connected = false;
+                reject(err);
+            });
+        });
+    }
+    close(code, data) {
+        this.socket && this.socket.close(code, data);
+    }
+    onClose(cb) {
+        if (!this.socket)
+            return;
+        this.socket.addEventListener(`close`, (event) => {
+            cb(event);
+        });
+    }
+    onError(cb) {
+        if (!this.socket)
+            return;
+        this.socket.addEventListener(`error`, (err) => {
+            cb(err);
+        });
+    }
+    clearEvent(event) {
+        this.events[event].listeners.forEach(listener => {
+            this.socket && this.socket.removeEventListener(`message`, listener);
+        });
+        Reflect.deleteProperty(this.events, event);
+    }
+    async closeAllListens(event) {
+        if (this.events[event]) {
+            const [err, _] = await to(this.call(`unsubscribe`, { notify: event }));
+            if (err)
+                return Promise.reject(err);
+            this.clearEvent(event);
+        }
+        return Promise.resolve();
+    }
+    async listenEvent(event, onData) {
+        const onMessage = (msgEvent) => {
+            if (this.events[event]) {
+                const { id } = this.events[event];
+                if (typeof msgEvent.data === `string`) {
+                    try {
+                        const data = JSON.parse(msgEvent.data);
+                        if (data.id === id) {
+                            if (data.error) {
+                                onData(msgEvent, undefined, new Error(data.error.message));
+                            }
+                            else {
+                                onData(msgEvent, data.result, undefined);
+                            }
+                        }
+                    }
+                    catch (_a) {
+                        // can't parse json -- do nothing
+                    }
+                }
+            }
+        };
+        if (this.events[event]) {
+            const { unsubscribeTimeoutId } = this.events[event];
+            if (unsubscribeTimeoutId) {
+                // clear timeout to unsubscribe 
+                // because we got a new registered event and want to cancel the pending unsubscribe grace period
+                clearTimeout(unsubscribeTimeoutId);
+            }
+            this.events[event].listeners.push(onMessage);
+        }
+        else {
+            // important if multiple listenEvent are called without await atleast we store listener before getting id
+            this.events[event] = { listeners: [onMessage] };
+            const [err, res] = await to(this.call(`subscribe`, { notify: event }));
+            if (err) {
+                this.clearEvent(event);
+                return Promise.reject(err);
+            }
+            this.events[event].id = res.id;
+        }
+        this.socket && this.socket.addEventListener(`message`, onMessage);
+        const closeListen = () => {
+            const eventData = this.events[event];
+            if (eventData) {
+                const listeners = eventData.listeners;
+                for (let i = 0; i < listeners.length; i++) {
+                    if (listeners[i] === onMessage) {
+                        listeners.splice(i, 1);
+                        break;
+                    }
+                }
+                if (listeners.length === 0) {
+                    this.events[event].unsubscribeTimeoutId = setTimeout(async () => {
+                        // no more listener so we unsubscribe from daemon websocket
+                        this.call(`unsubscribe`, { notify: event });
+                        Reflect.deleteProperty(this.events, event);
+                    }, this.unsubscribeSuspense);
+                }
+            }
+            this.socket && this.socket.removeEventListener(`message`, onMessage);
+            return Promise.resolve();
+        };
+        return Promise.resolve(closeListen);
+    }
+    call(method, params) {
+        return new Promise((resolve, reject) => {
+            const { data, id } = createRequestMethod(method, params);
+            let timeoutId = null;
+            const onMessage = (msgEvent) => {
+                if (typeof msgEvent.data === `string`) {
+                    const data = JSON.parse(msgEvent.data);
+                    if (data.id === id) {
+                        clearTimeout(timeoutId);
+                        this.socket && this.socket.removeEventListener(`message`, onMessage);
+                        if (data.error)
+                            return reject(new Error(data.error.message));
+                        else
+                            resolve(data);
+                    }
+                }
+            };
+            // make sure you listen before sending data
+            this.socket && this.socket.addEventListener(`message`, onMessage); // we don't use { once: true } option because of timeout feature
+            timeoutId = setTimeout(() => {
+                this.socket && this.socket.removeEventListener(`message`, onMessage);
+                reject(new Error(`timeout`));
+            }, this.timeout);
+            this.socket && this.socket.send(data);
+        });
+    }
+    dataCall(method, params) {
+        return new Promise(async (resolve, reject) => {
+            const [err, res] = await to(this.call(method, params));
+            if (err)
+                return reject(err);
+            return resolve(res.result);
+        });
+    }
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.4",
+  "version": "0.5.0",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
   "repository": {

package/wallet/rpc.d.ts

@@ -0,0 +1,16 @@
+import { Transaction } from '../daemon/types';
+import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams } from './types';
+import { RPC as BaseRPC } from '../lib/rpc';
+declare class RPC extends BaseRPC {
+    getVersion(): Promise<import("../lib/types").RPCResponse<string>>;
+    getNonce(): Promise<import("../lib/types").RPCResponse<number>>;
+    getTopoheight(): Promise<import("../lib/types").RPCResponse<number>>;
+    getAddress(params?: GetAddressParams): Promise<import("../lib/types").RPCResponse<string>>;
+    splitAddress(params: SplitAddressParams): Promise<import("../lib/types").RPCResponse<SplitAddressResult>>;
+    getBalance(asset?: string): Promise<import("../lib/types").RPCResponse<number>>;
+    getTrackedAssets(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<Transaction>>;
+    buildTransaction(params: BuildTransactionParams): Promise<import("../lib/types").RPCResponse<BuildTransactionResult>>;
+    listTransactions(params?: ListTransactionParams): Promise<import("../lib/types").RPCResponse<Transaction[]>>;
+}
+export default RPC;

package/wallet/rpc.js

@@ -0,0 +1,35 @@
+import { RPCMethod } from './types';
+import { RPC as BaseRPC } from '../lib/rpc';
+class RPC extends BaseRPC {
+    getVersion() {
+        return this.post(RPCMethod.GetVersion);
+    }
+    getNonce() {
+        return this.post(RPCMethod.GetNonce);
+    }
+    getTopoheight() {
+        return this.post(RPCMethod.GetTopoheight);
+    }
+    getAddress(params) {
+        return this.post(RPCMethod.GetAddress, params);
+    }
+    splitAddress(params) {
+        return this.post(RPCMethod.SplitAddress, params);
+    }
+    getBalance(asset) {
+        return this.post(RPCMethod.GetBalance, { asset });
+    }
+    getTrackedAssets() {
+        return this.post(RPCMethod.GetTrackedAssets);
+    }
+    getTransaction(hash) {
+        return this.post(RPCMethod.GetTransaction, { hash });
+    }
+    buildTransaction(params) {
+        return this.post(RPCMethod.BuildTransaction, params);
+    }
+    listTransactions(params) {
+        return this.post(RPCMethod.ListTransactions, params);
+    }
+}
+export default RPC;

package/wallet/types.d.ts

@@ -0,0 +1,42 @@
+import { TransactionData, Transaction } from '../daemon/types';
+export interface GetAddressParams {
+    integrated_data?: string;
+}
+export interface SplitAddressParams {
+    address: string;
+}
+export interface SplitAddressResult {
+    address: string;
+    integrated_data: string;
+}
+export interface BuildTransactionParams {
+    tx_type: TransactionData;
+    broadcast: boolean;
+    fee?: number;
+}
+export interface BuildTransactionResult {
+    hash: string;
+    data: Transaction;
+}
+export interface ListTransactionParams {
+    min_topoheight?: number;
+    max_topoheight?: number;
+    address?: string;
+    accept_incoming?: boolean;
+    accept_outgoing?: boolean;
+    accept_coinbase?: boolean;
+    accept_burn?: boolean;
+}
+export declare enum RPCMethod {
+    GetVersion = "get_version",
+    GetNetwork = "get_network",
+    GetNonce = "get_nonce",
+    GetTopoheight = "get_topoheight",
+    GetAddress = "get_address",
+    SplitAddress = "split_address",
+    GetBalance = "get_balance",
+    GetTrackedAssets = "get_tracked_assets",
+    GetTransaction = "get_transaction",
+    BuildTransaction = "build_transaction",
+    ListTransactions = "list_transactions"
+}

package/wallet/types.js

@@ -0,0 +1,14 @@
+export var RPCMethod;
+(function (RPCMethod) {
+    RPCMethod["GetVersion"] = "get_version";
+    RPCMethod["GetNetwork"] = "get_network";
+    RPCMethod["GetNonce"] = "get_nonce";
+    RPCMethod["GetTopoheight"] = "get_topoheight";
+    RPCMethod["GetAddress"] = "get_address";
+    RPCMethod["SplitAddress"] = "split_address";
+    RPCMethod["GetBalance"] = "get_balance";
+    RPCMethod["GetTrackedAssets"] = "get_tracked_assets";
+    RPCMethod["GetTransaction"] = "get_transaction";
+    RPCMethod["BuildTransaction"] = "build_transaction";
+    RPCMethod["ListTransactions"] = "list_transactions";
+})(RPCMethod || (RPCMethod = {}));

package/wallet/websocket.d.ts

@@ -0,0 +1,17 @@
+import { WS as BaseWS } from '../lib/websocket';
+import { Transaction } from '../daemon/types';
+import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult } from './types';
+declare class WS extends BaseWS {
+    getVersion(): Promise<string>;
+    getNetwork(): Promise<string>;
+    getNonce(): Promise<number>;
+    getTopoheight(): Promise<number>;
+    getAddress(params?: GetAddressParams): Promise<string>;
+    splitAddress(params: SplitAddressParams): Promise<SplitAddressResult>;
+    getBalance(asset?: string): Promise<number>;
+    getTrackedAssets(): Promise<string[]>;
+    getTransaction(hash: string): Promise<Transaction>;
+    buildTransaction(params: BuildTransactionParams): Promise<BuildTransactionResult>;
+    listTransactions(params?: ListTransactionParams): Promise<Transaction[]>;
+}
+export default WS;

package/wallet/websocket.js

@@ -0,0 +1,38 @@
+import { WS as BaseWS } from '../lib/websocket';
+import { RPCMethod } from './types';
+class WS extends BaseWS {
+    getVersion() {
+        return this.dataCall(RPCMethod.GetVersion);
+    }
+    getNetwork() {
+        return this.dataCall(RPCMethod.GetNetwork);
+    }
+    getNonce() {
+        return this.dataCall(RPCMethod.GetNonce);
+    }
+    getTopoheight() {
+        return this.dataCall(RPCMethod.GetTopoheight);
+    }
+    getAddress(params) {
+        return this.dataCall(RPCMethod.GetAddress, params);
+    }
+    splitAddress(params) {
+        return this.dataCall(RPCMethod.SplitAddress, params);
+    }
+    getBalance(asset) {
+        return this.dataCall(RPCMethod.GetBalance, { asset });
+    }
+    getTrackedAssets() {
+        return this.dataCall(RPCMethod.GetTrackedAssets);
+    }
+    getTransaction(hash) {
+        return this.dataCall(RPCMethod.GetTransaction, { hash });
+    }
+    buildTransaction(params) {
+        return this.dataCall(RPCMethod.BuildTransaction, params);
+    }
+    listTransactions(params) {
+        return this.dataCall(RPCMethod.GetTransaction, params);
+    }
+}
+export default WS;