@xelis/sdk 0.4.0 → 0.5.1

package/daemon/rpc.d.ts

@@ -1,4 +1,4 @@
-import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetLastBalanceResult, P2PStatusResult, Transaction, GetLastBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from '../lib/types';
+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>>;

package/daemon/rpc.js

@@ -1,86 +1,86 @@
-import { DaemonRPCMethod } from '../lib/types';
+import { RPCMethod } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
 class RPC extends BaseRPC {
     getVersion() {
-        return this.post(DaemonRPCMethod.GetVersion);
+        return this.post(RPCMethod.GetVersion);
     }
     getInfo() {
-        return this.post(DaemonRPCMethod.GetInfo);
+        return this.post(RPCMethod.GetInfo);
     }
     getHeight() {
-        return this.post(DaemonRPCMethod.GetHeight);
+        return this.post(RPCMethod.GetHeight);
     }
     getTopoHeight() {
-        return this.post(DaemonRPCMethod.GetTopoHeight);
+        return this.post(RPCMethod.GetTopoHeight);
     }
     getStableHeight() {
-        return this.post(DaemonRPCMethod.GetStableHeight);
+        return this.post(RPCMethod.GetStableHeight);
     }
     getBlockTemplate(address) {
-        return this.post(DaemonRPCMethod.GetBlockTemplate, { address });
+        return this.post(RPCMethod.GetBlockTemplate, { address });
     }
     getBlockAtTopoHeight(params) {
-        return this.post(DaemonRPCMethod.GetBlockAtTopoHeight, params);
+        return this.post(RPCMethod.GetBlockAtTopoHeight, params);
     }
     getBlocksAtHeight(params) {
-        return this.post(DaemonRPCMethod.GetBlocksAtHeight, params);
+        return this.post(RPCMethod.GetBlocksAtHeight, params);
     }
     getBlockByHash(params) {
-        return this.post(DaemonRPCMethod.GetBlockByHash, params);
+        return this.post(RPCMethod.GetBlockByHash, params);
     }
     getTopBlock(params) {
-        return this.post(DaemonRPCMethod.GetTopBlock, params);
+        return this.post(RPCMethod.GetTopBlock, params);
     }
     getNonce(address) {
-        return this.post(DaemonRPCMethod.GetNonce, { address });
+        return this.post(RPCMethod.GetNonce, { address });
     }
     getLastBalance(params) {
-        return this.post(DaemonRPCMethod.GetLastBalance, params);
+        return this.post(RPCMethod.GetLastBalance, params);
     }
     getBalanceAtTopoHeight(params) {
-        return this.post(DaemonRPCMethod.GetBalanceAtTopoHeight, params);
+        return this.post(RPCMethod.GetBalanceAtTopoHeight, params);
     }
     getAssets() {
-        return this.post(DaemonRPCMethod.GetAssets);
+        return this.post(RPCMethod.GetAssets);
     }
     countTransactions() {
-        return this.post(DaemonRPCMethod.CountTransactions);
+        return this.post(RPCMethod.CountTransactions);
     }
     countAssets() {
-        return this.post(DaemonRPCMethod.CountAssets);
+        return this.post(RPCMethod.CountAssets);
     }
     getTips() {
-        return this.post(DaemonRPCMethod.GetTips);
+        return this.post(RPCMethod.GetTips);
     }
     p2pStatus() {
-        return this.post(DaemonRPCMethod.P2PStatus);
+        return this.post(RPCMethod.P2PStatus);
     }
     getDAGOrder(params) {
-        return this.post(DaemonRPCMethod.GetDAGOrder, params);
+        return this.post(RPCMethod.GetDAGOrder, params);
     }
     getMemPool() {
-        return this.post(DaemonRPCMethod.GetMempool);
+        return this.post(RPCMethod.GetMempool);
     }
     getTransaction(hash) {
-        return this.post(DaemonRPCMethod.GetTransaction, { hash });
+        return this.post(RPCMethod.GetTransaction, { hash });
     }
     getTransactions(txHashes) {
-        return this.post(DaemonRPCMethod.GetTransactions, { tx_hashes: txHashes });
+        return this.post(RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
     getBlocksRangeByTopoheight(params) {
-        return this.post(DaemonRPCMethod.GetBlocksRangeByTopoheight, params);
+        return this.post(RPCMethod.GetBlocksRangeByTopoheight, params);
     }
     getBlocksRangeByHeight(params) {
-        return this.post(DaemonRPCMethod.GetBlocksRangeByHeight, params);
+        return this.post(RPCMethod.GetBlocksRangeByHeight, params);
     }
     getAccounts(params) {
-        return this.post(DaemonRPCMethod.GetAccounts, params);
+        return this.post(RPCMethod.GetAccounts, params);
     }
     submitBlock(blockTemplate) {
-        return this.post(DaemonRPCMethod.SubmitBlock, { block_template: blockTemplate });
+        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
     }
     submitTransaction(hexData) {
-        return this.post(DaemonRPCMethod.SubmitTransaction, { data: hexData });
+        return this.post(RPCMethod.SubmitTransaction, { data: hexData });
     }
 }
 export default RPC;

package/daemon/types.d.ts

@@ -0,0 +1,157 @@
+export interface GetInfoResult {
+    block_time_target: number;
+    difficulty: number;
+    height: number;
+    mempool_size: number;
+    native_supply: number;
+    stableheight: number;
+    top_hash: string;
+    version: string;
+    network: string;
+    topoheight: number;
+}
+export interface Block {
+    block_type: string;
+    cumulative_difficulty: number;
+    supply: number;
+    difficulty: number;
+    reward: number;
+    extra_nonce: string;
+    hash: string;
+    height: number;
+    miner_tx: {
+        owner: string;
+        signature: null;
+        variant: string;
+    };
+    miner: string;
+    nonce: number;
+    tips: string[];
+    topoheight: number;
+    total_fees: number;
+    total_size_in_bytes: number;
+    txs_hashes: string[];
+}
+export interface GetLastBalanceParams {
+    address: string;
+    asset: string;
+}
+export interface GetBalanceAtTopoHeightParams {
+    address: string;
+    asset: string;
+    topoheight: number;
+}
+export interface Balance {
+    balance: number;
+    previous_topoheight: number;
+}
+export interface GetLastBalanceResult {
+    topoheight: number;
+    balance: Balance;
+}
+export interface P2PStatusResult {
+    peer_count: number;
+    tag?: string;
+    peer_id: number;
+    our_topoheight: number;
+    best_topoheight: number;
+    max_peers: number;
+}
+export interface TopoHeightRangeParams {
+    start_topoheight?: number;
+    end_topoheight?: number;
+}
+export interface HeightRangeParams {
+    start_height?: number;
+    end_height?: number;
+}
+export interface RPCEventResult {
+    event: string;
+}
+export interface BlockOrdered {
+    topoheight: number;
+    block_hash: string;
+    block_type: string;
+}
+export interface Transfer {
+    amount: number;
+    asset: string;
+    extra_data?: any;
+    to: string;
+}
+export interface TransactionData {
+    transfers: Transfer[];
+    burn: {
+        asset: string;
+        amount: number;
+    };
+    call_contract: {
+        contract: string;
+    };
+    deploy_contract: string;
+}
+export interface Transaction {
+    hash: string;
+    blocks: string[];
+    data: TransactionData;
+    fee: number;
+    nonce: number;
+    owner: string;
+    signature: string;
+}
+export interface GetAccountsParams {
+    skip?: number;
+    maximum?: number;
+    minimum_topoheight?: number;
+    maximum_topoheight?: number;
+}
+export interface GetBlockAtTopoHeightParams {
+    topoheight: number;
+    include_txs?: boolean;
+}
+export interface GetBlocksAtHeightParams {
+    height: number;
+    include_txs?: boolean;
+}
+export interface GetBlockByHashParams {
+    hash: string;
+    include_txs?: boolean;
+}
+export interface GetTopBlockParams {
+    include_txs?: boolean;
+}
+export declare enum RPCMethod {
+    GetVersion = "get_version",
+    GetInfo = "get_info",
+    GetHeight = "get_height",
+    GetTopoHeight = "get_topoheight",
+    GetStableHeight = "get_stableheight",
+    GetBlockTemplate = "get_block_template",
+    GetBlockAtTopoHeight = "get_block_at_topoheight",
+    GetBlocksAtHeight = "get_blocks_at_height",
+    GetBlockByHash = "get_block_by_hash",
+    GetTopBlock = "get_top_block",
+    GetNonce = "get_nonce",
+    GetLastBalance = "get_last_balance",
+    GetBalanceAtTopoHeight = "get_balance_at_topoheight",
+    GetAssets = "get_assets",
+    CountAssets = "count_assets",
+    CountTransactions = "count_transactions",
+    GetTips = "get_tips",
+    P2PStatus = "p2p_status",
+    GetDAGOrder = "get_dag_order",
+    GetMempool = "get_mempool",
+    GetTransaction = "get_transaction",
+    GetTransactions = "get_transactions",
+    GetBlocksRangeByTopoheight = "get_blocks_range_by_topoheight",
+    GetBlocksRangeByHeight = "get_blocks_range_by_height",
+    GetAccounts = "get_accounts",
+    SubmitBlock = "submit_block",
+    SubmitTransaction = "submit_transaction"
+}
+export declare enum RPCEvent {
+    NewBlock = "NewBlock",
+    TransactionAddedInMempool = "TransactionAddedInMempool",
+    TransactionExecuted = "TransactionExecuted",
+    BlockOrdered = "BlockOrdered"
+}

package/daemon/types.js

@@ -0,0 +1,37 @@
+export var RPCMethod;
+(function (RPCMethod) {
+    RPCMethod["GetVersion"] = "get_version";
+    RPCMethod["GetInfo"] = "get_info";
+    RPCMethod["GetHeight"] = "get_height";
+    RPCMethod["GetTopoHeight"] = "get_topoheight";
+    RPCMethod["GetStableHeight"] = "get_stableheight";
+    RPCMethod["GetBlockTemplate"] = "get_block_template";
+    RPCMethod["GetBlockAtTopoHeight"] = "get_block_at_topoheight";
+    RPCMethod["GetBlocksAtHeight"] = "get_blocks_at_height";
+    RPCMethod["GetBlockByHash"] = "get_block_by_hash";
+    RPCMethod["GetTopBlock"] = "get_top_block";
+    RPCMethod["GetNonce"] = "get_nonce";
+    RPCMethod["GetLastBalance"] = "get_last_balance";
+    RPCMethod["GetBalanceAtTopoHeight"] = "get_balance_at_topoheight";
+    RPCMethod["GetAssets"] = "get_assets";
+    RPCMethod["CountAssets"] = "count_assets";
+    RPCMethod["CountTransactions"] = "count_transactions";
+    RPCMethod["GetTips"] = "get_tips";
+    RPCMethod["P2PStatus"] = "p2p_status";
+    RPCMethod["GetDAGOrder"] = "get_dag_order";
+    RPCMethod["GetMempool"] = "get_mempool";
+    RPCMethod["GetTransaction"] = "get_transaction";
+    RPCMethod["GetTransactions"] = "get_transactions";
+    RPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
+    RPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
+    RPCMethod["GetAccounts"] = "get_accounts";
+    RPCMethod["SubmitBlock"] = "submit_block";
+    RPCMethod["SubmitTransaction"] = "submit_transaction";
+})(RPCMethod || (RPCMethod = {}));
+export var RPCEvent;
+(function (RPCEvent) {
+    RPCEvent["NewBlock"] = "NewBlock";
+    RPCEvent["TransactionAddedInMempool"] = "TransactionAddedInMempool";
+    RPCEvent["TransactionExecuted"] = "TransactionExecuted";
+    RPCEvent["BlockOrdered"] = "BlockOrdered";
+})(RPCEvent || (RPCEvent = {}));

package/daemon/websocket.d.ts

@@ -1,5 +1,5 @@
 import { MessageEvent } from 'ws';
-import { Block, GetInfoResult, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetLastBalanceResult, HeightRangeParams, BlockOrdered, GetLastBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams } from '../lib/types';
+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>>;

package/daemon/websocket.js

@@ -1,4 +1,4 @@
-import { RPCEvent, DaemonRPCMethod } from '../lib/types';
+import { RPCEvent, RPCMethod } from './types';
 import { WS as BaseWS } from '../lib/websocket';
 class WS extends BaseWS {
     onNewBlock(onData) {
@@ -14,82 +14,82 @@ class WS extends BaseWS {
         return this.listenEvent(RPCEvent.BlockOrdered, onData);
     }
     getVersion() {
-        return this.dataCall(DaemonRPCMethod.GetVersion);
+        return this.dataCall(RPCMethod.GetVersion);
     }
     getInfo() {
-        return this.dataCall(DaemonRPCMethod.GetInfo);
+        return this.dataCall(RPCMethod.GetInfo);
     }
     getHeight() {
-        return this.dataCall(DaemonRPCMethod.GetHeight);
+        return this.dataCall(RPCMethod.GetHeight);
     }
     getTopoHeight() {
-        return this.dataCall(DaemonRPCMethod.GetTopoHeight);
+        return this.dataCall(RPCMethod.GetTopoHeight);
     }
     getStableHeight() {
-        return this.dataCall(DaemonRPCMethod.GetStableHeight);
+        return this.dataCall(RPCMethod.GetStableHeight);
     }
     getBlockTemplate(address) {
-        return this.dataCall(DaemonRPCMethod.GetBlockTemplate, { address });
+        return this.dataCall(RPCMethod.GetBlockTemplate, { address });
     }
     getBlockAtTopoHeight(params) {
-        return this.dataCall(DaemonRPCMethod.GetBlockAtTopoHeight, params);
+        return this.dataCall(RPCMethod.GetBlockAtTopoHeight, params);
     }
     getBlocksAtHeight(params) {
-        return this.dataCall(DaemonRPCMethod.GetBlocksAtHeight, params);
+        return this.dataCall(RPCMethod.GetBlocksAtHeight, params);
     }
     getBlockByHash(params) {
-        return this.dataCall(DaemonRPCMethod.GetBlockByHash, params);
+        return this.dataCall(RPCMethod.GetBlockByHash, params);
     }
     getTopBlock(params) {
-        return this.dataCall(DaemonRPCMethod.GetTopBlock, params);
+        return this.dataCall(RPCMethod.GetTopBlock, params);
     }
     getNonce(address) {
-        return this.dataCall(DaemonRPCMethod.GetNonce, { address });
+        return this.dataCall(RPCMethod.GetNonce, { address });
     }
     getLastBalance(params) {
-        return this.dataCall(DaemonRPCMethod.GetLastBalance, params);
+        return this.dataCall(RPCMethod.GetLastBalance, params);
     }
     getBalanceAtTopoHeight(params) {
-        return this.dataCall(DaemonRPCMethod.GetBalanceAtTopoHeight, params);
+        return this.dataCall(RPCMethod.GetBalanceAtTopoHeight, params);
     }
     getAssets() {
-        return this.dataCall(DaemonRPCMethod.GetAssets);
+        return this.dataCall(RPCMethod.GetAssets);
     }
     countTransactions() {
-        return this.dataCall(DaemonRPCMethod.CountTransactions);
+        return this.dataCall(RPCMethod.CountTransactions);
     }
     getTips() {
-        return this.dataCall(DaemonRPCMethod.GetTips);
+        return this.dataCall(RPCMethod.GetTips);
     }
     p2pStatus() {
-        return this.dataCall(DaemonRPCMethod.P2PStatus);
+        return this.dataCall(RPCMethod.P2PStatus);
     }
     getDAGOrder(params) {
-        return this.dataCall(DaemonRPCMethod.GetDAGOrder, params);
+        return this.dataCall(RPCMethod.GetDAGOrder, params);
     }
     getMemPool() {
-        return this.dataCall(DaemonRPCMethod.GetMempool);
+        return this.dataCall(RPCMethod.GetMempool);
     }
     getTransaction(hash) {
-        return this.dataCall(DaemonRPCMethod.GetTransaction, { hash });
+        return this.dataCall(RPCMethod.GetTransaction, { hash });
     }
     getTransactions(txHashes) {
-        return this.dataCall(DaemonRPCMethod.GetTransactions, { tx_hashes: txHashes });
+        return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
     getBlocksRangeByTopoheight(params) {
-        return this.dataCall(DaemonRPCMethod.GetBlocksRangeByTopoheight, params);
+        return this.dataCall(RPCMethod.GetBlocksRangeByTopoheight, params);
     }
     getBlocksRangeByHeight(params) {
-        return this.dataCall(DaemonRPCMethod.GetBlocksRangeByHeight, params);
+        return this.dataCall(RPCMethod.GetBlocksRangeByHeight, params);
     }
     getAccounts(params) {
-        return this.dataCall(DaemonRPCMethod.GetAccounts, params);
+        return this.dataCall(RPCMethod.GetAccounts, params);
     }
     submitBlock(blockTemplate) {
-        return this.dataCall(DaemonRPCMethod.SubmitBlock, { block_template: blockTemplate });
+        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
     }
     submitTransaction(hexData) {
-        return this.dataCall(DaemonRPCMethod.SubmitTransaction, { data: hexData });
+        return this.dataCall(RPCMethod.SubmitTransaction, { data: hexData });
     }
 }
 export default WS;

package/lib/rpc.d.ts

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

package/lib/rpc.js

@@ -1,11 +1,21 @@
 export class RPC {
     constructor(endpoint) {
         this.endpoint = endpoint;
+        this.timeout = 3000;
     }
     async post(method, params) {
         try {
+            const controller = new AbortController();
             const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
-            const res = await fetch(this.endpoint, { method: `POST`, body });
+            const timeoutId = setTimeout(() => {
+                controller.abort();
+            }, this.timeout);
+            const res = await fetch(this.endpoint, {
+                method: `POST`,
+                body,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
             if (res.ok) {
                 const data = await res.json();
                 if (data.error) {

package/lib/types.d.ts

@@ -13,201 +13,3 @@ export interface RPCResponse<T> {
     result: T;
     error?: RPCError;
 }
-export interface GetInfoResult {
-    block_time_target: number;
-    difficulty: number;
-    height: number;
-    mempool_size: number;
-    native_supply: number;
-    stableheight: number;
-    top_hash: string;
-    version: string;
-    network: string;
-    topoheight: number;
-}
-export interface Block {
-    block_type: string;
-    cumulative_difficulty: number;
-    supply: number;
-    difficulty: number;
-    reward: number;
-    extra_nonce: string;
-    hash: string;
-    height: number;
-    miner_tx: {
-        owner: string;
-        signature: null;
-        variant: string;
-    };
-    miner: string;
-    nonce: number;
-    tips: string[];
-    topoheight: number;
-    total_fees: number;
-    total_size_in_bytes: number;
-    txs_hashes: string[];
-}
-export interface GetLastBalanceParams {
-    address: string;
-    asset: string;
-}
-export interface GetBalanceAtTopoHeightParams {
-    address: string;
-    asset: string;
-    topoheight: number;
-}
-export interface Balance {
-    balance: number;
-    previous_topoheight: number;
-}
-export interface GetLastBalanceResult {
-    topoheight: number;
-    balance: Balance;
-}
-export interface P2PStatusResult {
-    peer_count: number;
-    tag?: string;
-    peer_id: number;
-    our_topoheight: number;
-    best_topoheight: number;
-    max_peers: number;
-}
-export interface TopoHeightRangeParams {
-    start_topoheight?: number;
-    end_topoheight?: number;
-}
-export interface HeightRangeParams {
-    start_height?: number;
-    end_height?: number;
-}
-export interface RPCEventResult {
-    event: string;
-}
-export interface BlockOrdered {
-    topoheight: number;
-    block_hash: string;
-    block_type: string;
-}
-export interface Transfer {
-    amount: number;
-    asset: string;
-    extra_data?: any;
-    to: string;
-}
-export interface TransactionData {
-    transfers: Transfer[];
-    burn: {
-        asset: string;
-        amount: number;
-    };
-    call_contract: {
-        contract: string;
-    };
-    deploy_contract: string;
-}
-export interface Transaction {
-    hash: string;
-    blocks: string[];
-    data: TransactionData;
-    fee: number;
-    nonce: number;
-    owner: string;
-    signature: string;
-}
-export interface GetAccountsParams {
-    skip?: number;
-    maximum?: number;
-    minimum_topoheight?: number;
-    maximum_topoheight?: number;
-}
-export interface GetBlockAtTopoHeightParams {
-    topoheight: number;
-    include_txs?: boolean;
-}
-export interface GetBlocksAtHeightParams {
-    height: number;
-    include_txs?: boolean;
-}
-export interface GetBlockByHashParams {
-    hash: string;
-    include_txs?: boolean;
-}
-export interface GetTopBlockParams {
-    include_txs?: boolean;
-}
-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 WalletRPCMethod {
-    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"
-}
-export declare enum DaemonRPCMethod {
-    GetVersion = "get_version",
-    GetInfo = "get_info",
-    GetHeight = "get_height",
-    GetTopoHeight = "get_topoheight",
-    GetStableHeight = "get_stableheight",
-    GetBlockTemplate = "get_block_template",
-    GetBlockAtTopoHeight = "get_block_at_topoheight",
-    GetBlocksAtHeight = "get_blocks_at_height",
-    GetBlockByHash = "get_block_by_hash",
-    GetTopBlock = "get_top_block",
-    GetNonce = "get_nonce",
-    GetLastBalance = "get_last_balance",
-    GetBalanceAtTopoHeight = "get_balance_at_topoheight",
-    GetAssets = "get_assets",
-    CountAssets = "count_assets",
-    CountTransactions = "count_transactions",
-    GetTips = "get_tips",
-    P2PStatus = "p2p_status",
-    GetDAGOrder = "get_dag_order",
-    GetMempool = "get_mempool",
-    GetTransaction = "get_transaction",
-    GetTransactions = "get_transactions",
-    GetBlocksRangeByTopoheight = "get_blocks_range_by_topoheight",
-    GetBlocksRangeByHeight = "get_blocks_range_by_height",
-    GetAccounts = "get_accounts",
-    SubmitBlock = "submit_block",
-    SubmitTransaction = "submit_transaction"
-}
-export declare enum RPCEvent {
-    NewBlock = "NewBlock",
-    TransactionAddedInMempool = "TransactionAddedInMempool",
-    TransactionExecuted = "TransactionExecuted",
-    BlockOrdered = "BlockOrdered"
-}

package/lib/types.js

@@ -1,51 +1 @@
-export var WalletRPCMethod;
-(function (WalletRPCMethod) {
-    WalletRPCMethod["GetVersion"] = "get_version";
-    WalletRPCMethod["GetNetwork"] = "get_network";
-    WalletRPCMethod["GetNonce"] = "get_nonce";
-    WalletRPCMethod["GetTopoheight"] = "get_topoheight";
-    WalletRPCMethod["GetAddress"] = "get_address";
-    WalletRPCMethod["SplitAddress"] = "split_address";
-    WalletRPCMethod["GetBalance"] = "get_balance";
-    WalletRPCMethod["GetTrackedAssets"] = "get_tracked_assets";
-    WalletRPCMethod["GetTransaction"] = "get_transaction";
-    WalletRPCMethod["BuildTransaction"] = "build_transaction";
-    WalletRPCMethod["ListTransactions"] = "list_transactions";
-})(WalletRPCMethod || (WalletRPCMethod = {}));
-export var DaemonRPCMethod;
-(function (DaemonRPCMethod) {
-    DaemonRPCMethod["GetVersion"] = "get_version";
-    DaemonRPCMethod["GetInfo"] = "get_info";
-    DaemonRPCMethod["GetHeight"] = "get_height";
-    DaemonRPCMethod["GetTopoHeight"] = "get_topoheight";
-    DaemonRPCMethod["GetStableHeight"] = "get_stableheight";
-    DaemonRPCMethod["GetBlockTemplate"] = "get_block_template";
-    DaemonRPCMethod["GetBlockAtTopoHeight"] = "get_block_at_topoheight";
-    DaemonRPCMethod["GetBlocksAtHeight"] = "get_blocks_at_height";
-    DaemonRPCMethod["GetBlockByHash"] = "get_block_by_hash";
-    DaemonRPCMethod["GetTopBlock"] = "get_top_block";
-    DaemonRPCMethod["GetNonce"] = "get_nonce";
-    DaemonRPCMethod["GetLastBalance"] = "get_last_balance";
-    DaemonRPCMethod["GetBalanceAtTopoHeight"] = "get_balance_at_topoheight";
-    DaemonRPCMethod["GetAssets"] = "get_assets";
-    DaemonRPCMethod["CountAssets"] = "count_assets";
-    DaemonRPCMethod["CountTransactions"] = "count_transactions";
-    DaemonRPCMethod["GetTips"] = "get_tips";
-    DaemonRPCMethod["P2PStatus"] = "p2p_status";
-    DaemonRPCMethod["GetDAGOrder"] = "get_dag_order";
-    DaemonRPCMethod["GetMempool"] = "get_mempool";
-    DaemonRPCMethod["GetTransaction"] = "get_transaction";
-    DaemonRPCMethod["GetTransactions"] = "get_transactions";
-    DaemonRPCMethod["GetBlocksRangeByTopoheight"] = "get_blocks_range_by_topoheight";
-    DaemonRPCMethod["GetBlocksRangeByHeight"] = "get_blocks_range_by_height";
-    DaemonRPCMethod["GetAccounts"] = "get_accounts";
-    DaemonRPCMethod["SubmitBlock"] = "submit_block";
-    DaemonRPCMethod["SubmitTransaction"] = "submit_transaction";
-})(DaemonRPCMethod || (DaemonRPCMethod = {}));
-export var RPCEvent;
-(function (RPCEvent) {
-    RPCEvent["NewBlock"] = "NewBlock";
-    RPCEvent["TransactionAddedInMempool"] = "TransactionAddedInMempool";
-    RPCEvent["TransactionExecuted"] = "TransactionExecuted";
-    RPCEvent["BlockOrdered"] = "BlockOrdered";
-})(RPCEvent || (RPCEvent = {}));
+export {};

package/lib/websocket.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
-import { RPCResponse, RPCEvent, RPCEventResult } from './types';
+import { RPCResponse } from './types';
 export declare class WS {
     endpoint: string;
     socket?: WebSocket;
@@ -15,8 +15,8 @@ export declare class WS {
     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 & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    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/package.json

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

package/react/daemon.d.ts

@@ -1,7 +1,7 @@
 import React, { PropsWithChildren } from 'react';
 import { MessageEvent } from 'ws';
 import DaemonWS from '../daemon/websocket';
-import { RPCEvent } from '../lib/types';
+import { RPCEvent } from '../daemon/types';
 interface NodeSocket {
     daemon: DaemonWS;
     loading: boolean;

package/wallet/rpc.d.ts

@@ -1,4 +1,5 @@
-import { Transaction, GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams } from '../lib/types';
+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>>;

package/wallet/rpc.js

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

@@ -1,5 +1,6 @@
 import { WS as BaseWS } from '../lib/websocket';
-import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult, Transaction } from '../lib/types';
+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>;

package/wallet/websocket.js

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