@xelis/sdk 0.6.1 → 0.8.0

package/dist/esm/xswd/websocket.js

@@ -0,0 +1,35 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { WS as BaseWS } from '../lib/websocket';
+import { DaemonMethods } from '../daemon/websocket';
+import { WalletMethods } from '../wallet/websocket';
+var WS = /** @class */ (function (_super) {
+    __extends(WS, _super);
+    function WS() {
+        var _this = _super.call(this) || this;
+        _this.timeout = 0;
+        _this.daemon = new DaemonMethods(_this, "node.");
+        _this.wallet = new WalletMethods(_this, "wallet.");
+        return _this;
+    }
+    WS.prototype.authorize = function (app) {
+        var data = JSON.stringify(app);
+        return this.call("", {}, data);
+    };
+    return WS;
+}(BaseWS));
+export { WS };
+export default WS;

package/{daemon → dist/types/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';
 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 → dist/types/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 → dist/types/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,31 +29,34 @@ 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>;
 }
 export declare class WS extends BaseWS {
     methods: DaemonMethods;

package/{wallet → dist/types/wallet}/rpc.d.ts

@@ -1,5 +1,5 @@
-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';
 export declare class RPC extends BaseRPC {
@@ -7,17 +7,21 @@ export declare class RPC extends BaseRPC {
     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 → dist/types/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 → dist/types/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,15 +11,17 @@ 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>;
 }
 export declare class WS extends BaseWS {
     methods: WalletMethods;

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/*.spec.ts'],
+}

package/package.json

@@ -1,7 +1,15 @@
 {
-  "version": "0.6.1",
+  "version": "0.8.0",
   "name": "@xelis/sdk",
   "description": "Xelis software development kit for JS",
+  "exports": {
+    "./*": {
+      "types": "./dist/types/*.d.ts",
+      "require": "./dist/cjs/*.js",
+      "import": "./dist/esm/*.js",
+      "default": "./dist/esm/*.js"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/xelis-project/xelis-js-sdk"
@@ -9,8 +17,9 @@
   "homepage": "https://github.com/xelis-project/xelis-js-sdk#readme",
   "scripts": {
     "test": "jest",
-    "build": "rm -rf ./dist && npx tsc --declaration && cp package.json README.md LICENSE ./dist",
-    "publish-npm": "npm run build && cd ./dist && npm publish"
+    "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
+    "clean": "rm -rf ./dist",
+    "build": "npm run clean && npm run compile && node create_esm_pkg.js"
   },
   "devDependencies": {
     "@types/jest": "^29.4.0",

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "commonjs"
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "ES2015"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "jsx": "react",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.types.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/types",
+    "declaration": true,
+    "emitDeclarationOnly": true
+  }
+}