@xelis/sdk 0.6.0 → 0.7.0

package/README.md

@@ -15,8 +15,12 @@ Import library and start working :).
 Use Daemon HTTP RPC connection.
 
 ```js
+// ESM
 import { TESTNET_NODE_RPC } from '@xelis/sdk/config'
 import DaemonRPC from '@xelis/sdk/daemon/rpc'
+// CommonJS
+// const { TESTNET_NODE_RPC } = require('@xelis/sdk/config')
+// const { RPC: DaemonRPC } = require('@xelis/sdk/daemon/rpc')
 
 const main = async () => {
   const daemon = new DaemonRPC(TESTNET_NODE_RPC)
@@ -30,8 +34,12 @@ main()
 Use Daemon WebSocket RPC connection.
 
 ```js
+// ESM
 import { TESTNET_NODE_WS } from '@xelis/sdk/config'
 import DaemonWS from '@xelis/sdk/daemon/websocket'
+// CommonJS
+// const { TESTNET_NODE_RPC } = require('@xelis/sdk/config')
+// const { WS: DaemonWS } = require('@xelis/sdk/daemon/websocket')
 
 const main = async () => {
   const daemon = new DaemonWS()
@@ -46,8 +54,12 @@ main()
 Use Wallet WebSocket RPC connection.
 
 ```js
+// ESM
 import { LOCAL_WALLET_WS } from '@xelis/sdk/config'
 import DaemonWS from '@xelis/sdk/wallet/websocket'
+// CommonJS
+// const { LOCAL_WALLET_WS } = require('@xelis/sdk/config')
+// const { WS: WalletWS } = require('@xelis/sdk/wallet/websocket')
 
 const main = async () => {
   const wallet = new WalletWS(`test`, `test`) // username, password
@@ -62,8 +74,12 @@ main()
 Use XSWD protocol.
 
 ```js
+// ESM
 import { LOCAL_XSWD_WS } from '@xelis/sdk/config'
 import XSWD from '@xelis/sdk/xswd/websocket'
+// CommonJS
+// const { LOCAL_XSWD_WS } = require('@xelis/sdk/config')
+// const { WS: XSWD } = require('@xelis/sdk/xswd/websocket')
 
 const main = async () => {
   const xswd = new XSWD()

package/daemon/rpc.d.ts

@@ -1,41 +1,43 @@
-import { Balance, Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetBalanceResult, P2PStatusResult, Transaction, GetBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceResult, GetNonceParams, GetAccountHistoryParams, AccounHistory, Peer, DevFee, DiskSize, HasBalanceParams, HasBalanceResult, AssetData, IsTxExecutedInBlockParams, GetAssetParams } from './types';
+import { Block, TopoHeightRangeParams, GetInfoResult, HeightRangeParams, GetBalanceResult, P2PStatusResult, GetBalanceParams, GetBalanceAtTopoHeightParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceResult, GetNonceParams, GetAccountHistoryParams, AccounHistory, DevFee, DiskSize, HasBalanceParams, HasBalanceResult, AssetData, IsTxExecutedInBlockParams, GetAssetParams, GetPeersResult, GetBlockTemplateResult, VersionedBalance, VersionedNonce, GetNonceAtTopoheightParams, HasNonceParams, HasNonceResult, TransactionResponse } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
-declare class RPC extends BaseRPC {
+export 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>>;
+    getBlockTemplate(address: string): Promise<import("../lib/types").RPCResponse<GetBlockTemplateResult>>;
     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(params: GetNonceParams): Promise<import("../lib/types").RPCResponse<GetNonceResult>>;
+    submitBlock(blockTemplate: string): Promise<import("../lib/types").RPCResponse<boolean>>;
     getBalance(params: GetBalanceParams): Promise<import("../lib/types").RPCResponse<GetBalanceResult>>;
     hasBalance(params: HasBalanceParams): Promise<import("../lib/types").RPCResponse<HasBalanceResult>>;
-    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<Balance>>;
+    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<import("../lib/types").RPCResponse<VersionedBalance>>;
+    getInfo(): Promise<import("../lib/types").RPCResponse<GetInfoResult>>;
+    getNonce(params: GetNonceParams): Promise<import("../lib/types").RPCResponse<GetNonceResult>>;
+    hasNonce(params: HasNonceParams): Promise<import("../lib/types").RPCResponse<HasNonceResult>>;
+    getNonceAtTopoheight(params: GetNonceAtTopoheightParams): Promise<import("../lib/types").RPCResponse<VersionedNonce>>;
     getAsset(params: GetAssetParams): Promise<import("../lib/types").RPCResponse<AssetData>>;
     getAssets(): Promise<import("../lib/types").RPCResponse<string[]>>;
-    countTransactions(): Promise<import("../lib/types").RPCResponse<number>>;
     countAssets(): Promise<import("../lib/types").RPCResponse<number>>;
     countAccounts(): Promise<import("../lib/types").RPCResponse<number>>;
-    getTips(): Promise<import("../lib/types").RPCResponse<string[]>>;
+    countTransactions(): Promise<import("../lib/types").RPCResponse<number>>;
+    submitTransaction(hexData: string): Promise<import("../lib/types").RPCResponse<boolean>>;
+    getTransaction(hash: string): Promise<import("../lib/types").RPCResponse<TransactionResponse>>;
     p2pStatus(): Promise<import("../lib/types").RPCResponse<P2PStatusResult>>;
+    getPeers(): Promise<import("../lib/types").RPCResponse<GetPeersResult>>;
+    getMemPool(): Promise<import("../lib/types").RPCResponse<TransactionResponse[]>>;
+    getTips(): Promise<import("../lib/types").RPCResponse<string[]>>;
     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>>;
+    getTransactions(txHashes: string[]): Promise<import("../lib/types").RPCResponse<TransactionResponse[]>>;
     getAccountHistory(params: GetAccountHistoryParams): Promise<import("../lib/types").RPCResponse<AccounHistory[]>>;
     getAccountAssets(address: string): Promise<import("../lib/types").RPCResponse<string[]>>;
-    getPeers(): Promise<import("../lib/types").RPCResponse<Peer[]>>;
+    getAccounts(params: GetAccountsParams): Promise<import("../lib/types").RPCResponse<string[]>>;
+    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<import("../lib/types").RPCResponse<boolean>>;
     getDevFeeThresholds(): Promise<import("../lib/types").RPCResponse<DevFee[]>>;
     getSizeOnDisk(): Promise<import("../lib/types").RPCResponse<DiskSize>>;
-    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<import("../lib/types").RPCResponse<boolean>>;
 }
 export default RPC;

package/daemon/rpc.js

@@ -1,12 +1,9 @@
 import { RPCMethod } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
-class RPC extends BaseRPC {
+export class RPC extends BaseRPC {
     getVersion() {
         return this.post(RPCMethod.GetVersion);
     }
-    getInfo() {
-        return this.post(RPCMethod.GetInfo);
-    }
     getHeight() {
         return this.post(RPCMethod.GetHeight);
     }
@@ -31,8 +28,8 @@ class RPC extends BaseRPC {
     getTopBlock(params) {
         return this.post(RPCMethod.GetTopBlock, params);
     }
-    getNonce(params) {
-        return this.post(RPCMethod.GetNonce, params);
+    submitBlock(blockTemplate) {
+        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
     }
     getBalance(params) {
         return this.post(RPCMethod.GetBalance, params);
@@ -43,38 +40,53 @@ class RPC extends BaseRPC {
     getBalanceAtTopoHeight(params) {
         return this.post(RPCMethod.GetBalanceAtTopoHeight, params);
     }
+    getInfo() {
+        return this.post(RPCMethod.GetInfo);
+    }
+    getNonce(params) {
+        return this.post(RPCMethod.GetNonce, params);
+    }
+    hasNonce(params) {
+        return this.post(RPCMethod.HasNonce, params);
+    }
+    getNonceAtTopoheight(params) {
+        return this.post(RPCMethod.GetNonceAtTopoheight, params);
+    }
     getAsset(params) {
         return this.post(RPCMethod.GetAsset, params);
     }
     getAssets() {
         return this.post(RPCMethod.GetAssets);
     }
-    countTransactions() {
-        return this.post(RPCMethod.CountTransactions);
-    }
     countAssets() {
         return this.post(RPCMethod.CountAssets);
     }
     countAccounts() {
         return this.post(RPCMethod.CountAccounts);
     }
-    getTips() {
-        return this.post(RPCMethod.GetTips);
+    countTransactions() {
+        return this.post(RPCMethod.CountTransactions);
+    }
+    submitTransaction(hexData) {
+        return this.post(RPCMethod.SubmitTransaction, { data: hexData });
+    }
+    getTransaction(hash) {
+        return this.post(RPCMethod.GetTransaction, { hash });
     }
     p2pStatus() {
         return this.post(RPCMethod.P2PStatus);
     }
-    getDAGOrder(params) {
-        return this.post(RPCMethod.GetDAGOrder, params);
+    getPeers() {
+        return this.post(RPCMethod.GetPeers);
     }
     getMemPool() {
         return this.post(RPCMethod.GetMempool);
     }
-    getTransaction(hash) {
-        return this.post(RPCMethod.GetTransaction, { hash });
+    getTips() {
+        return this.post(RPCMethod.GetTips);
     }
-    getTransactions(txHashes) {
-        return this.post(RPCMethod.GetTransactions, { tx_hashes: txHashes });
+    getDAGOrder(params) {
+        return this.post(RPCMethod.GetDAGOrder, params);
     }
     getBlocksRangeByTopoheight(params) {
         return this.post(RPCMethod.GetBlocksRangeByTopoheight, params);
@@ -82,14 +94,8 @@ class RPC extends BaseRPC {
     getBlocksRangeByHeight(params) {
         return this.post(RPCMethod.GetBlocksRangeByHeight, params);
     }
-    getAccounts(params) {
-        return this.post(RPCMethod.GetAccounts, params);
-    }
-    submitBlock(blockTemplate) {
-        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
-    }
-    submitTransaction(hexData) {
-        return this.post(RPCMethod.SubmitTransaction, { data: hexData });
+    getTransactions(txHashes) {
+        return this.post(RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
     getAccountHistory(params) {
         return this.post(RPCMethod.GetAccountHistory, params);
@@ -97,8 +103,11 @@ class RPC extends BaseRPC {
     getAccountAssets(address) {
         return this.post(RPCMethod.GetAccountAssets, { address });
     }
-    getPeers() {
-        return this.post(RPCMethod.GetPeers);
+    getAccounts(params) {
+        return this.post(RPCMethod.GetAccounts, params);
+    }
+    isTxExecutedInBlock(params) {
+        return this.post(RPCMethod.IsTxExecutedInBlock, params);
     }
     getDevFeeThresholds() {
         return this.post(RPCMethod.GetDevFeeThresholds);
@@ -106,8 +115,5 @@ class RPC extends BaseRPC {
     getSizeOnDisk() {
         return this.post(RPCMethod.GetSizeOnDisk);
     }
-    isTxExecutedInBlock(params) {
-        return this.post(RPCMethod.IsTxExecutedInBlock, params);
-    }
 }
 export default RPC;

package/daemon/types.d.ts

@@ -1,34 +1,38 @@
 export interface GetInfoResult {
+    average_block_time: number;
+    block_reward: number;
     block_time_target: number;
-    difficulty: number;
-    height: number;
-    mempool_size: number;
     circulating_supply: number;
+    difficulty: string;
+    height: number;
     maximum_supply: number;
+    mempool_size: number;
+    network: string;
+    pruned_topoheight?: number;
     stableheight: number;
     top_block_hash: string;
-    version: string;
-    network: string;
     topoheight: number;
+    version: string;
 }
 export interface Block {
-    block_type: string;
-    cumulative_difficulty: number;
-    supply: number;
-    difficulty: number;
-    reward: number;
-    extra_nonce: string;
     hash: string;
+    topoheight?: number;
+    block_type: BlockType;
+    difficulty: string;
+    supply?: number;
+    reward?: number;
+    cumulative_difficulty: string;
+    total_fees?: number;
+    total_size_in_bytes: number;
+    version: number;
+    tips: string[];
+    timestamp: number;
     height: number;
-    miner: string;
     nonce: number;
-    tips: string[];
-    topoheight: number;
-    total_fees: number;
-    total_size_in_bytes: number;
-    transactions?: Transaction[];
+    extra_nonce: string;
+    miner: string;
     txs_hashes: string[];
-    version: number;
+    transactions?: Transaction[];
 }
 export interface GetBalanceParams {
     address: string;
@@ -43,17 +47,35 @@ export interface GetNonceParams {
     address: string;
     topoheight: number;
 }
-export interface GetNonceResult {
+export interface VersionedNonce {
     nonce: number;
-    previous_topoheight: number;
+    previous_topoheight?: number;
+}
+export interface GetNonceResult {
+    version: VersionedNonce;
+    topoheight: number;
+}
+export interface GetNonceAtTopoheightParams {
+    address: string;
     topoheight: number;
 }
-export interface Balance {
-    balance: number;
-    previous_topoheight: number;
+export interface EncryptedBalance {
+    commitment: number[];
+    handle: number[];
+}
+export declare enum BalanceType {
+    Input = "input",
+    Output = "output",
+    Both = "both"
+}
+export interface VersionedBalance {
+    balance_type: BalanceType;
+    final_balance: EncryptedBalance;
+    output_balance?: EncryptedBalance;
+    previous_topoheight?: number;
 }
 export interface GetBalanceResult {
-    version: Balance;
+    version: VersionedBalance;
     topoheight: number;
 }
 export interface P2PStatusResult {
@@ -76,20 +98,22 @@ export interface RPCEventResult {
     event: string;
 }
 export type PeerPeers = {
-    [ip: string]: `In` | `Out` | `Both`;
+    [addr: string]: `In` | `Out` | `Both`;
 };
 export interface Peer {
     id: number;
     addr: string;
-    tag: string;
+    local_port: number;
+    tag?: string;
     version: string;
     top_block_hash: string;
     topoheight: number;
     height: number;
     last_ping: number;
-    pruned_topoheight: number;
+    pruned_topoheight?: number;
     peers: PeerPeers;
-    cumulative_difficulty: number;
+    cumulative_difficulty: string;
+    connected_on: number;
 }
 export interface BlockOrdered {
     topoheight: number;
@@ -100,31 +124,66 @@ export interface BlockOrphaned {
     block_hash: string;
     old_topoheight: number;
 }
+export interface StableHeightChanged {
+    previous_stable_height: number;
+    new_stable_height: number;
+}
+export interface Proof {
+    Y_0: number[];
+    Y_1: number[];
+    z_r: number[];
+    z_x: number[];
+}
+export interface EqProof {
+    Y_0: number[];
+    Y_1: number[];
+    Y_2: number[];
+    z_r: number[];
+    z_s: number[];
+    z_x: number[];
+}
 export interface Transfer {
-    amount: number;
     asset: string;
+    destination: string;
     extra_data?: any;
-    to: string;
+    commitment: number[];
+    sender_handle: number[];
+    receiver_handle: number[];
+    ct_validity_proof: Proof;
+}
+export interface Burn {
+    asset: string;
+    amount: number;
 }
 export interface TransactionData {
     transfers: Transfer[];
-    burn: {
-        asset: string;
-        amount: number;
-    };
-    call_contract: {
-        contract: string;
-    };
-    deploy_contract: string;
+    burn: Burn;
+}
+export interface SourceCommitment {
+    commitment: number[];
+    proof: EqProof;
+    asset: string;
+}
+export interface Reference {
+    hash: string;
+    topoheight: number;
 }
 export interface Transaction {
     hash: string;
-    blocks: string[];
+    version: number;
+    source: string;
     data: TransactionData;
     fee: number;
     nonce: number;
-    owner: string;
+    source_commitments: SourceCommitment[];
+    range_proof: number[];
     signature: string;
+    reference: Reference;
+}
+export interface TransactionResponse extends Transaction {
+    blocks: string[];
+    executed_in_block: string;
+    in_mempool: boolean;
     first_seen?: number;
 }
 export interface GetAccountsParams {
@@ -156,7 +215,6 @@ export interface GetAccountHistoryParams {
 }
 export interface AccounHistory {
     topoheight: number;
-    block_timestamp: number;
     hash: string;
     mining?: {
         reward: number;
@@ -165,11 +223,12 @@ export interface AccounHistory {
         amount: number;
     };
     outgoing?: {
-        amount: number;
+        to: string;
     };
     incoming?: {
-        amount: number;
+        from: string;
     };
+    block_timestamp: number;
 }
 export interface PeerPeerListUpdated {
     peer_id: number;
@@ -203,6 +262,9 @@ export interface HasBalanceParams {
 export interface HasBalanceResult {
     exists: boolean;
 }
+export interface HasNonceResult {
+    exists: boolean;
+}
 export interface IsTxExecutedInBlockParams {
     tx_hash: string;
     block_hash: string;
@@ -210,12 +272,26 @@ export interface IsTxExecutedInBlockParams {
 export interface GetAssetParams {
     asset: string;
 }
+export interface GetPeersResult {
+    peers: Peer[];
+    total_peers: number;
+    hidden_peers: number;
+}
 export declare enum BlockType {
     Sync = "Sync",
     Normal = "Normal",
     Side = "Side",
     Orphaned = "Orphaned"
 }
+export interface GetBlockTemplateResult {
+    template: string;
+    height: number;
+    difficulty: number;
+}
+export interface HasNonceParams {
+    address: string;
+    topoheight?: number;
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetInfo = "get_info",
@@ -228,6 +304,8 @@ export declare enum RPCMethod {
     GetBlockByHash = "get_block_by_hash",
     GetTopBlock = "get_top_block",
     GetNonce = "get_nonce",
+    GetNonceAtTopoheight = "get_nonce_at_topoheight",
+    HasNonce = "has_nonce",
     GetBalance = "get_balance",
     HasBalance = "has_balance",
     GetBalanceAtTopoHeight = "get_balance_at_topoheight",
@@ -256,15 +334,17 @@ export declare enum RPCMethod {
 }
 export declare enum RPCEvent {
     NewBlock = "new_block",
+    BlockOrdered = "block_ordered",
+    BlockOrphaned = "block_orphaned",
+    StableHeightChanged = "stable_height_changed",
+    TransactionOrphaned = "transaction_orphaned",
     TransactionAddedInMempool = "transaction_added_in_mempool",
     TransactionExecuted = "transaction_executed",
-    BlockOrdered = "block_ordered",
     TransactionSCResult = "transaction_sc_result",
     NewAsset = "new_asset",
     PeerConnected = "peer_connected",
     PeerDisconnected = "peer_disconnected",
-    PeerStateUpdated = "peer_state_updated",
     PeerPeerListUpdated = "peer_peer_list_updated",
-    PeerPeerDisconnected = "peer_peer_disconnected",
-    BlockOrphaned = "block_orphaned"
+    PeerStateUpdated = "peer_state_updated",
+    PeerPeerDisconnected = "peer_peer_disconnected"
 }

package/daemon/types.js

@@ -1,3 +1,9 @@
+export var BalanceType;
+(function (BalanceType) {
+    BalanceType["Input"] = "input";
+    BalanceType["Output"] = "output";
+    BalanceType["Both"] = "both";
+})(BalanceType || (BalanceType = {}));
 export var BlockType;
 (function (BlockType) {
     BlockType["Sync"] = "Sync";
@@ -18,6 +24,8 @@ export var RPCMethod;
     RPCMethod["GetBlockByHash"] = "get_block_by_hash";
     RPCMethod["GetTopBlock"] = "get_top_block";
     RPCMethod["GetNonce"] = "get_nonce";
+    RPCMethod["GetNonceAtTopoheight"] = "get_nonce_at_topoheight";
+    RPCMethod["HasNonce"] = "has_nonce";
     RPCMethod["GetBalance"] = "get_balance";
     RPCMethod["HasBalance"] = "has_balance";
     RPCMethod["GetBalanceAtTopoHeight"] = "get_balance_at_topoheight";
@@ -47,15 +55,17 @@ export var RPCMethod;
 export var RPCEvent;
 (function (RPCEvent) {
     RPCEvent["NewBlock"] = "new_block";
+    RPCEvent["BlockOrdered"] = "block_ordered";
+    RPCEvent["BlockOrphaned"] = "block_orphaned";
+    RPCEvent["StableHeightChanged"] = "stable_height_changed";
+    RPCEvent["TransactionOrphaned"] = "transaction_orphaned";
     RPCEvent["TransactionAddedInMempool"] = "transaction_added_in_mempool";
     RPCEvent["TransactionExecuted"] = "transaction_executed";
-    RPCEvent["BlockOrdered"] = "block_ordered";
     RPCEvent["TransactionSCResult"] = "transaction_sc_result";
     RPCEvent["NewAsset"] = "new_asset";
     RPCEvent["PeerConnected"] = "peer_connected";
     RPCEvent["PeerDisconnected"] = "peer_disconnected";
-    RPCEvent["PeerStateUpdated"] = "peer_state_updated";
     RPCEvent["PeerPeerListUpdated"] = "peer_peer_list_updated";
+    RPCEvent["PeerStateUpdated"] = "peer_state_updated";
     RPCEvent["PeerPeerDisconnected"] = "peer_peer_disconnected";
-    RPCEvent["BlockOrphaned"] = "block_orphaned";
 })(RPCEvent || (RPCEvent = {}));

package/daemon/websocket.d.ts

@@ -1,5 +1,5 @@
 import { MessageEvent } from 'ws';
-import { Block, GetInfoResult, RPCEventResult, Transaction, TopoHeightRangeParams, P2PStatusResult, Balance, GetBalanceAtTopoHeightParams, GetBalanceResult, HeightRangeParams, BlockOrdered, GetBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceParams, GetNonceResult, GetAccountHistoryParams, AccounHistory, Peer, PeerPeerListUpdated, PeerPeerDisconnected, DevFee, DiskSize, AssetWithData, AssetData, GetAssetParams, HasBalanceParams, HasBalanceResult, IsTxExecutedInBlockParams, BlockOrphaned } from './types';
+import { Block, GetInfoResult, GetPeersResult, RPCEventResult, TopoHeightRangeParams, P2PStatusResult, GetBalanceAtTopoHeightParams, GetBalanceResult, HeightRangeParams, BlockOrdered, GetBalanceParams, GetAccountsParams, GetBlockAtTopoHeightParams, GetBlockByHashParams, GetBlocksAtHeightParams, GetTopBlockParams, GetNonceParams, GetNonceResult, GetAccountHistoryParams, AccounHistory, Peer, PeerPeerListUpdated, PeerPeerDisconnected, DevFee, DiskSize, AssetWithData, AssetData, GetAssetParams, HasBalanceParams, HasBalanceResult, IsTxExecutedInBlockParams, BlockOrphaned, VersionedBalance, StableHeightChanged, HasNonceResult, HasNonceParams, TransactionResponse } from './types';
 import { WS as BaseWS } from '../lib/websocket';
 export declare class DaemonMethods {
     ws: BaseWS;
@@ -8,8 +8,8 @@ export declare class DaemonMethods {
     listenEvent<T>(event: string, onData: (msgEvent: MessageEvent, data?: T, err?: Error) => void): Promise<() => Promise<void>>;
     dataCall<T>(method: string, params?: any): Promise<T>;
     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>>;
+    onTransactionAddedInMempool(onData: (msgEvent: MessageEvent, data?: TransactionResponse & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onTransactionExecuted(onData: (msgEvent: MessageEvent, data?: TransactionResponse & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onBlockOrdered(onData: (msgEvent: MessageEvent, data?: BlockOrdered & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onPeerConnected(onData: (msgEvent: MessageEvent, data?: Peer & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onPeerDisconnected(onData: (msgEvent: MessageEvent, data?: number & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
@@ -18,8 +18,9 @@ export declare class DaemonMethods {
     onPeerStateUpdated(onData: (msgEvent: MessageEvent, data?: Peer & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onNewAsset(onData: (msgEvent: MessageEvent, data?: AssetWithData & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     onBlockOrphaned(onData: (msgEvent: MessageEvent, data?: BlockOrphaned & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onTransactionOrphaned(onData: (msgEvent: MessageEvent, data?: TransactionResponse & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
+    onStableHeightChanged(onData: (msgEvent: MessageEvent, data?: StableHeightChanged & RPCEventResult, err?: Error) => void): Promise<() => Promise<void>>;
     getVersion(): Promise<string>;
-    getInfo(): Promise<GetInfoResult>;
     getHeight(): Promise<number>;
     getTopoHeight(): Promise<number>;
     getStableHeight(): Promise<number>;
@@ -28,33 +29,36 @@ export declare class DaemonMethods {
     getBlocksAtHeight(params: GetBlocksAtHeightParams): Promise<Block[]>;
     getBlockByHash(params: GetBlockByHashParams): Promise<Block>;
     getTopBlock(params: GetTopBlockParams): Promise<Block>;
-    getNonce(params: GetNonceParams): Promise<GetNonceResult>;
+    submitBlock(blockTemplate: string): Promise<boolean>;
     getBalance(params: GetBalanceParams): Promise<GetBalanceResult>;
     hasBalance(params: HasBalanceParams): Promise<HasBalanceResult>;
-    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<Balance>;
+    getBalanceAtTopoHeight(params: GetBalanceAtTopoHeightParams): Promise<VersionedBalance>;
+    getInfo(): Promise<GetInfoResult>;
+    getNonce(params: GetNonceParams): Promise<GetNonceResult>;
+    hasNonce(params: HasNonceParams): Promise<HasNonceResult>;
     getAsset(params: GetAssetParams): Promise<AssetData>;
     getAssets(): Promise<string[]>;
+    countAssets(): Promise<number>;
+    countAccounts(): Promise<number>;
     countTransactions(): Promise<number>;
-    getTips(): Promise<string[]>;
+    submitTransaction(hexData: string): Promise<boolean>;
+    getTransaction(hash: string): Promise<TransactionResponse>;
     p2pStatus(): Promise<P2PStatusResult>;
+    getPeers(): Promise<GetPeersResult>;
+    getMemPool(): Promise<TransactionResponse[]>;
+    getTips(): Promise<string[]>;
     getDAGOrder(params: TopoHeightRangeParams): Promise<string[]>;
-    getMemPool(): Promise<Transaction[]>;
-    getTransaction(hash: string): Promise<Transaction>;
-    getTransactions(txHashes: string[]): Promise<Transaction[]>;
     getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<Block[]>;
     getBlocksRangeByHeight(params: HeightRangeParams): Promise<Block[]>;
-    getAccounts(params: GetAccountsParams): Promise<string[]>;
-    submitBlock(blockTemplate: string): Promise<boolean>;
-    submitTransaction(hexData: string): Promise<boolean>;
-    countAccounts(): Promise<number>;
+    getTransactions(txHashes: string[]): Promise<TransactionResponse[]>;
     getAccountHistory(params: GetAccountHistoryParams): Promise<AccounHistory[]>;
     getAccountAssets(address: string): Promise<string[]>;
-    getPeers(): Promise<Peer[]>;
+    getAccounts(params: GetAccountsParams): Promise<string[]>;
+    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<boolean>;
     getDevFeeThresholds(): Promise<DevFee[]>;
     getSizeOnDisk(): Promise<DiskSize>;
-    isTxExecutedInBlock(params: IsTxExecutedInBlockParams): Promise<boolean>;
 }
-declare class WS extends BaseWS {
+export declare class WS extends BaseWS {
     methods: DaemonMethods;
     constructor();
 }

package/daemon/websocket.js

@@ -44,12 +44,15 @@ export class DaemonMethods {
     onBlockOrphaned(onData) {
         return this.listenEvent(RPCEvent.BlockOrphaned, onData);
     }
+    onTransactionOrphaned(onData) {
+        return this.listenEvent(RPCEvent.TransactionOrphaned, onData);
+    }
+    onStableHeightChanged(onData) {
+        return this.listenEvent(RPCEvent.StableHeightChanged, onData);
+    }
     getVersion() {
         return this.dataCall(RPCMethod.GetVersion);
     }
-    getInfo() {
-        return this.dataCall(RPCMethod.GetInfo);
-    }
     getHeight() {
         return this.dataCall(RPCMethod.GetHeight);
     }
@@ -74,8 +77,8 @@ export class DaemonMethods {
     getTopBlock(params) {
         return this.dataCall(RPCMethod.GetTopBlock, params);
     }
-    getNonce(params) {
-        return this.dataCall(RPCMethod.GetNonce, params);
+    submitBlock(blockTemplate) {
+        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
     }
     getBalance(params) {
         return this.dataCall(RPCMethod.GetBalance, params);
@@ -86,32 +89,50 @@ export class DaemonMethods {
     getBalanceAtTopoHeight(params) {
         return this.dataCall(RPCMethod.GetBalanceAtTopoHeight, params);
     }
+    getInfo() {
+        return this.dataCall(RPCMethod.GetInfo);
+    }
+    getNonce(params) {
+        return this.dataCall(RPCMethod.GetNonce, params);
+    }
+    hasNonce(params) {
+        return this.dataCall(RPCMethod.HasNonce, params);
+    }
     getAsset(params) {
         return this.dataCall(RPCMethod.GetAsset, params);
     }
     getAssets() {
         return this.dataCall(RPCMethod.GetAssets);
     }
+    countAssets() {
+        return this.dataCall(RPCMethod.CountAssets);
+    }
+    countAccounts() {
+        return this.dataCall(RPCMethod.CountAccounts);
+    }
     countTransactions() {
         return this.dataCall(RPCMethod.CountTransactions);
     }
-    getTips() {
-        return this.dataCall(RPCMethod.GetTips);
+    submitTransaction(hexData) {
+        return this.dataCall(RPCMethod.SubmitTransaction, { data: hexData });
+    }
+    getTransaction(hash) {
+        return this.dataCall(RPCMethod.GetTransaction, { hash });
     }
     p2pStatus() {
         return this.dataCall(RPCMethod.P2PStatus);
     }
-    getDAGOrder(params) {
-        return this.dataCall(RPCMethod.GetDAGOrder, params);
+    getPeers() {
+        return this.dataCall(RPCMethod.GetPeers);
     }
     getMemPool() {
         return this.dataCall(RPCMethod.GetMempool);
     }
-    getTransaction(hash) {
-        return this.dataCall(RPCMethod.GetTransaction, { hash });
+    getTips() {
+        return this.dataCall(RPCMethod.GetTips);
     }
-    getTransactions(txHashes) {
-        return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
+    getDAGOrder(params) {
+        return this.dataCall(RPCMethod.GetDAGOrder, params);
     }
     getBlocksRangeByTopoheight(params) {
         return this.dataCall(RPCMethod.GetBlocksRangeByTopoheight, params);
@@ -119,17 +140,8 @@ export class DaemonMethods {
     getBlocksRangeByHeight(params) {
         return this.dataCall(RPCMethod.GetBlocksRangeByHeight, params);
     }
-    getAccounts(params) {
-        return this.dataCall(RPCMethod.GetAccounts, params);
-    }
-    submitBlock(blockTemplate) {
-        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
-    }
-    submitTransaction(hexData) {
-        return this.dataCall(RPCMethod.SubmitTransaction, { data: hexData });
-    }
-    countAccounts() {
-        return this.dataCall(RPCMethod.CountAccounts);
+    getTransactions(txHashes) {
+        return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
     }
     getAccountHistory(params) {
         return this.dataCall(RPCMethod.GetAccountHistory, params);
@@ -137,8 +149,11 @@ export class DaemonMethods {
     getAccountAssets(address) {
         return this.dataCall(RPCMethod.GetAccountAssets, { address });
     }
-    getPeers() {
-        return this.dataCall(RPCMethod.GetPeers);
+    getAccounts(params) {
+        return this.dataCall(RPCMethod.GetAccounts, params);
+    }
+    isTxExecutedInBlock(params) {
+        return this.dataCall(RPCMethod.IsTxExecutedInBlock, params);
     }
     getDevFeeThresholds() {
         return this.dataCall(RPCMethod.GetDevFeeThresholds);
@@ -146,11 +161,8 @@ export class DaemonMethods {
     getSizeOnDisk() {
         return this.dataCall(RPCMethod.GetSizeOnDisk);
     }
-    isTxExecutedInBlock(params) {
-        return this.dataCall(RPCMethod.IsTxExecutedInBlock, params);
-    }
 }
-class WS extends BaseWS {
+export class WS extends BaseWS {
     constructor() {
         super();
         this.methods = new DaemonMethods(this);

package/lib/websocket.js

@@ -5,7 +5,7 @@ export class WS {
         this.connectionTries = 0;
         this.methodIdIncrement = 0;
         this.endpoint = "";
-        this.timeout = 3000;
+        this.timeout = 15000; // default to 15s
         this.events = {};
         this.unsubscribeSuspense = 1000;
         this.maxConnectionTries = 3;

package/package.json

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

package/react/daemon.d.ts

@@ -10,6 +10,7 @@ interface NodeSocket {
 }
 interface NodeSocketProviderProps {
     endpoint: string;
+    timeout?: number;
 }
 export declare const NodeSocketProvider: (props: PropsWithChildren<NodeSocketProviderProps>) => React.JSX.Element;
 interface NodeSocketSubscribeProps<T> {

package/react/daemon.js

@@ -1,15 +1,15 @@
 import React, { createContext, useContext, useEffect, useState } from 'react';
 import to from 'await-to-js';
 import DaemonWS from '../daemon/websocket';
-const daemon = new DaemonWS();
 export const INITIATING = -1;
+const daemon = new DaemonWS();
 const Context = createContext({
     err: undefined,
     daemon,
     readyState: INITIATING
 });
 export const NodeSocketProvider = (props) => {
-    const { children, endpoint } = props;
+    const { children, endpoint, timeout } = props;
     const [readyState, setReadyState] = useState(INITIATING);
     const [err, setErr] = useState();
     useEffect(() => {
@@ -21,6 +21,11 @@ export const NodeSocketProvider = (props) => {
         };
         connect();
     }, [endpoint]);
+    useEffect(() => {
+        if (!timeout)
+            return;
+        daemon.timeout = timeout;
+    }, [timeout]);
     useEffect(() => {
         if (!daemon.socket)
             return;

package/wallet/rpc.d.ts

@@ -1,23 +1,27 @@
-import { Transaction, GetAssetParams } from '../daemon/types';
-import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams } from './types';
+import { GetAssetParams, HasBalanceResult, TransactionData } from '../daemon/types';
+import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams, Signature, TransactionEntry } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
 import { RPCResponse } from '../lib/types';
-declare class RPC extends BaseRPC {
+export declare class RPC extends BaseRPC {
     auth: string;
     constructor(endpoint: string, username: string, password: string);
     post<T>(method: string, params?: any): Promise<RPCResponse<T>>;
     getVersion(): Promise<RPCResponse<string>>;
+    getNetwork(): Promise<RPCResponse<string>>;
     getNonce(): Promise<RPCResponse<number>>;
     getTopoheight(): Promise<RPCResponse<number>>;
     getAddress(params?: GetAddressParams): Promise<RPCResponse<string>>;
-    rescan(): Promise<RPCResponse<void>>;
     splitAddress(params: SplitAddressParams): Promise<RPCResponse<SplitAddressResult>>;
+    rescan(): Promise<RPCResponse<void>>;
     getBalance(asset?: string): Promise<RPCResponse<number>>;
+    hasBalance(asset?: string): Promise<RPCResponse<HasBalanceResult>>;
     getTrackedAssets(): Promise<RPCResponse<string[]>>;
     getAssetPrecision(params: GetAssetParams): Promise<RPCResponse<number>>;
-    getTransaction(hash: string): Promise<RPCResponse<Transaction>>;
+    getTransaction(hash: string): Promise<RPCResponse<TransactionEntry>>;
     buildTransaction(params: BuildTransactionParams): Promise<RPCResponse<BuildTransactionResult>>;
-    listTransactions(params?: ListTransactionParams): Promise<RPCResponse<Transaction[]>>;
+    listTransactions(params?: ListTransactionParams): Promise<RPCResponse<TransactionEntry[]>>;
     isOnline(): Promise<RPCResponse<boolean>>;
+    signData(data: any): Promise<RPCResponse<Signature>>;
+    estimateFees(txData: TransactionData): Promise<RPCResponse<number>>;
 }
 export default RPC;

package/wallet/rpc.js

@@ -1,7 +1,7 @@
 import { Base64 } from 'js-base64';
 import { RPCMethod } from './types';
 import { RPC as BaseRPC } from '../lib/rpc';
-class RPC extends BaseRPC {
+export class RPC extends BaseRPC {
     constructor(endpoint, username, password) {
         super(endpoint);
         const authValue = Base64.encode(`${username}:${password}`);
@@ -15,6 +15,9 @@ class RPC extends BaseRPC {
     getVersion() {
         return this.post(RPCMethod.GetVersion);
     }
+    getNetwork() {
+        return this.post(RPCMethod.GetNetwork);
+    }
     getNonce() {
         return this.post(RPCMethod.GetNonce);
     }
@@ -24,15 +27,18 @@ class RPC extends BaseRPC {
     getAddress(params = {}) {
         return this.post(RPCMethod.GetAddress, params);
     }
-    rescan() {
-        return this.post(RPCMethod.Rescan);
-    }
     splitAddress(params) {
         return this.post(RPCMethod.SplitAddress, params);
     }
+    rescan() {
+        return this.post(RPCMethod.Rescan);
+    }
     getBalance(asset) {
         return this.post(RPCMethod.GetBalance, { asset });
     }
+    hasBalance(asset) {
+        return this.post(RPCMethod.HasBalance, { asset });
+    }
     getTrackedAssets() {
         return this.post(RPCMethod.GetTrackedAssets);
     }
@@ -51,5 +57,11 @@ class RPC extends BaseRPC {
     isOnline() {
         return this.post(RPCMethod.IsOnline);
     }
+    signData(data) {
+        return this.post(RPCMethod.SignData, data);
+    }
+    estimateFees(txData) {
+        return this.post(RPCMethod.EstimateFees, { tx_type: txData });
+    }
 }
 export default RPC;

package/wallet/types.d.ts

@@ -27,6 +27,31 @@ export interface ListTransactionParams {
     accept_coinbase?: boolean;
     accept_burn?: boolean;
 }
+export interface Signature {
+    s: number[];
+    e: number[];
+}
+export interface TxCoinbase {
+    reward: number;
+}
+export interface TxBurn {
+    asset: string;
+    amount: number;
+}
+export interface TxIncoming {
+    from: string;
+    transfers: any;
+}
+export interface TxOutgoing {
+    transfers: any;
+    fees: number;
+    nonce: number;
+}
+export interface TransactionEntry {
+    hash: string;
+    topoheight: number;
+    entry: TxCoinbase | TxBurn | TxIncoming | TxOutgoing;
+}
 export declare enum RPCMethod {
     GetVersion = "get_version",
     GetNetwork = "get_network",
@@ -36,6 +61,7 @@ export declare enum RPCMethod {
     SplitAddress = "split_address",
     Rescan = "rescan",
     GetBalance = "get_balance",
+    HasBalance = "has_balance",
     GetTrackedAssets = "get_tracked_assets",
     GetAssetPrecision = "get_asset_precision",
     GetTransaction = "get_transaction",

package/wallet/types.js

@@ -8,6 +8,7 @@ export var RPCMethod;
     RPCMethod["SplitAddress"] = "split_address";
     RPCMethod["Rescan"] = "rescan";
     RPCMethod["GetBalance"] = "get_balance";
+    RPCMethod["HasBalance"] = "has_balance";
     RPCMethod["GetTrackedAssets"] = "get_tracked_assets";
     RPCMethod["GetAssetPrecision"] = "get_asset_precision";
     RPCMethod["GetTransaction"] = "get_transaction";

package/wallet/websocket.d.ts

@@ -1,6 +1,6 @@
 import { WS as BaseWS } from '../lib/websocket';
-import { GetAssetParams, Transaction } from '../daemon/types';
-import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult } from './types';
+import { GetAssetParams, TransactionData } from '../daemon/types';
+import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult, Signature, TransactionEntry } from './types';
 export declare class WalletMethods {
     ws: BaseWS;
     prefix: string;
@@ -11,17 +11,19 @@ export declare class WalletMethods {
     getNonce(): Promise<number>;
     getTopoheight(): Promise<number>;
     getAddress(params?: GetAddressParams): Promise<string>;
-    rescan(): Promise<void>;
     splitAddress(params: SplitAddressParams): Promise<SplitAddressResult>;
+    rescan(): Promise<void>;
     getBalance(asset?: string): Promise<number>;
     getTrackedAssets(): Promise<string[]>;
     getAssetPrecision(params: GetAssetParams): Promise<number>;
-    getTransaction(hash: string): Promise<Transaction>;
+    getTransaction(hash: string): Promise<TransactionEntry>;
     buildTransaction(params: BuildTransactionParams): Promise<BuildTransactionResult>;
-    listTransactions(params?: ListTransactionParams): Promise<Transaction[]>;
+    listTransactions(params?: ListTransactionParams): Promise<TransactionEntry[]>;
     isOnline(): Promise<boolean>;
+    signData(data: any): Promise<Signature>;
+    estimateFees(txData: TransactionData): Promise<number>;
 }
-declare class WS extends BaseWS {
+export declare class WS extends BaseWS {
     methods: WalletMethods;
     constructor(username: string, password: string);
 }

package/wallet/websocket.js

@@ -23,12 +23,12 @@ export class WalletMethods {
     getAddress(params = {}) {
         return this.dataCall(RPCMethod.GetAddress, params);
     }
-    rescan() {
-        return this.dataCall(RPCMethod.Rescan);
-    }
     splitAddress(params) {
         return this.dataCall(RPCMethod.SplitAddress, params);
     }
+    rescan() {
+        return this.dataCall(RPCMethod.Rescan);
+    }
     getBalance(asset) {
         return this.dataCall(RPCMethod.GetBalance, { asset });
     }
@@ -50,8 +50,14 @@ export class WalletMethods {
     isOnline() {
         return this.dataCall(RPCMethod.IsOnline);
     }
+    signData(data) {
+        return this.dataCall(RPCMethod.SignData, data);
+    }
+    estimateFees(txData) {
+        return this.dataCall(RPCMethod.EstimateFees, { tx_type: txData });
+    }
 }
-class WS extends BaseWS {
+export class WS extends BaseWS {
     constructor(username, password) {
         super({ auth: `${username}:${password}` });
         this.methods = new WalletMethods(this);

package/xswd/websocket.d.ts

@@ -2,7 +2,7 @@ import { WS as BaseWS } from '../lib/websocket';
 import { ApplicationData } from '../wallet/types';
 import { DaemonMethods } from '../daemon/websocket';
 import { WalletMethods } from '../wallet/websocket';
-declare class WS extends BaseWS {
+export declare class WS extends BaseWS {
     daemon: DaemonMethods;
     wallet: WalletMethods;
     constructor();

package/xswd/websocket.js

@@ -1,7 +1,7 @@
 import { WS as BaseWS } from '../lib/websocket';
 import { DaemonMethods } from '../daemon/websocket';
 import { WalletMethods } from '../wallet/websocket';
-class WS extends BaseWS {
+export class WS extends BaseWS {
     constructor() {
         super();
         this.timeout = 0;