@xelis/sdk 0.7.0 → 0.8.1

package/dist/types/daemon/rpc.d.ts

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

package/{daemon → dist/types/daemon}/websocket.d.ts

@@ -1,6 +1,6 @@
 import { MessageEvent } from 'ws';
-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';
+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.js';
+import { WS as BaseWS } from '../lib/websocket.js';
 export declare class DaemonMethods {
     ws: BaseWS;
     prefix: string;

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

@@ -1,4 +1,4 @@
-import { RPCResponse } from './types';
+import { RPCResponse } from './types.js';
 export declare class RPC {
     endpoint: string;
     timeout: number;

package/{lib → dist/types/lib}/websocket.d.ts

@@ -2,7 +2,7 @@
 import { ClientOptions, MessageEvent } from 'ws';
 import WebSocket from 'isomorphic-ws';
 import { ClientRequestArgs } from 'http';
-import { RPCResponse } from './types';
+import { RPCResponse } from './types.js';
 export declare class WS {
     endpoint: string;
     socket?: WebSocket;

package/{react → dist/types/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 '../daemon/types';
+import DaemonWS from '../daemon/websocket.js';
+import { RPCEvent } from '../daemon/types.js';
 export declare const INITIATING = -1;
 interface NodeSocket {
     daemon: DaemonWS;

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

@@ -1,7 +1,7 @@
-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';
+import { GetAssetParams, HasBalanceResult, TransactionData } from '../daemon/types.js';
+import { GetAddressParams, SplitAddressParams, SplitAddressResult, BuildTransactionParams, BuildTransactionResult, ListTransactionParams, Signature, TransactionEntry } from './types.js';
+import { RPC as BaseRPC } from '../lib/rpc.js';
+import { RPCResponse } from '../lib/types.js';
 export declare class RPC extends BaseRPC {
     auth: string;
     constructor(endpoint: string, username: string, password: string);

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

@@ -1,4 +1,4 @@
-import { TransactionData, Transaction } from '../daemon/types';
+import { TransactionData, Transaction } from '../daemon/types.js';
 export interface GetAddressParams {
     integrated_data?: string;
 }

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

@@ -1,6 +1,6 @@
-import { WS as BaseWS } from '../lib/websocket';
-import { GetAssetParams, TransactionData } from '../daemon/types';
-import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult, Signature, TransactionEntry } from './types';
+import { WS as BaseWS } from '../lib/websocket.js';
+import { GetAssetParams, TransactionData } from '../daemon/types.js';
+import { BuildTransactionParams, BuildTransactionResult, GetAddressParams, ListTransactionParams, SplitAddressParams, SplitAddressResult, Signature, TransactionEntry } from './types.js';
 export declare class WalletMethods {
     ws: BaseWS;
     prefix: string;

package/dist/types/xswd/websocket.d.ts

@@ -0,0 +1,11 @@
+import { WS as BaseWS } from '../lib/websocket.js';
+import { ApplicationData } from '../wallet/types.js';
+import { DaemonMethods } from '../daemon/websocket.js';
+import { WalletMethods } from '../wallet/websocket.js';
+export declare class WS extends BaseWS {
+    daemon: DaemonMethods;
+    wallet: WalletMethods;
+    constructor();
+    authorize(app: ApplicationData): Promise<import("../lib/types.js").RPCResponse<unknown>>;
+}
+export default WS;

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.7.0",
+  "version": "0.8.1",
   "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": "ESNext"
+  }
+}

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
+  }
+}

package/config.js

@@ -1,25 +0,0 @@
-export const DAEMON_RPC_PORT = `8080`;
-export const WALLET_RPC_PORT = `8081`;
-export const XSWD_PORT = `44325`;
-export const MAINNET_NODE_URL = `node.xelis.io`;
-export const TESTNET_NODE_URL = `testnet-node.xelis.io`;
-export const LOCAL_NODE_URL = `127.0.0.1:${DAEMON_RPC_PORT}`;
-export const MAINNET_NODE_RPC = `https://${MAINNET_NODE_URL}/json_rpc`;
-export const TESTNET_NODE_RPC = `https://${TESTNET_NODE_URL}/json_rpc`;
-export const LOCAL_NODE_RPC = `http://${LOCAL_NODE_URL}/json_rpc`;
-export const MAINNET_NODE_WS = `wss://${MAINNET_NODE_URL}/json_rpc`;
-export const TESTNET_NODE_WS = `wss://${TESTNET_NODE_URL}/json_rpc`;
-export const LOCAL_NODE_WS = `ws://${LOCAL_NODE_URL}/json_rpc`;
-export const LOCAL_WALLET_URL = `127.0.0.1:${WALLET_RPC_PORT}`;
-export const LOCAL_WALLET_RPC = `http://${LOCAL_WALLET_URL}/json_rpc`;
-export const LOCAL_WALLET_WS = `ws://${LOCAL_WALLET_URL}/json_rpc`;
-export const LOCAL_XSWD_URL = `127.0.0.1:${XSWD_PORT}`;
-export const LOCAL_XSWD_WS = `ws://${LOCAL_XSWD_URL}/xswd`;
-export default {
-    MAINNET_NODE_URL, TESTNET_NODE_URL,
-    MAINNET_NODE_RPC, TESTNET_NODE_RPC, LOCAL_NODE_RPC,
-    MAINNET_NODE_WS, TESTNET_NODE_WS, LOCAL_NODE_WS,
-    DAEMON_RPC_PORT, WALLET_RPC_PORT, XSWD_PORT,
-    LOCAL_WALLET_URL, LOCAL_WALLET_RPC, LOCAL_WALLET_WS,
-    LOCAL_XSWD_URL, LOCAL_XSWD_WS
-};

package/daemon/rpc.d.ts

@@ -1,43 +0,0 @@
-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>>;
-    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<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>>;
-    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<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[]>>;
-    countAssets(): Promise<import("../lib/types").RPCResponse<number>>;
-    countAccounts(): Promise<import("../lib/types").RPCResponse<number>>;
-    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[]>>;
-    getBlocksRangeByTopoheight(params: TopoHeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
-    getBlocksRangeByHeight(params: HeightRangeParams): Promise<import("../lib/types").RPCResponse<Block[]>>;
-    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[]>>;
-    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>>;
-}
-export default RPC;

package/daemon/rpc.js

@@ -1,119 +0,0 @@
-import { RPCMethod } from './types';
-import { RPC as BaseRPC } from '../lib/rpc';
-export class RPC extends BaseRPC {
-    getVersion() {
-        return this.post(RPCMethod.GetVersion);
-    }
-    getHeight() {
-        return this.post(RPCMethod.GetHeight);
-    }
-    getTopoHeight() {
-        return this.post(RPCMethod.GetTopoHeight);
-    }
-    getStableHeight() {
-        return this.post(RPCMethod.GetStableHeight);
-    }
-    getBlockTemplate(address) {
-        return this.post(RPCMethod.GetBlockTemplate, { address });
-    }
-    getBlockAtTopoHeight(params) {
-        return this.post(RPCMethod.GetBlockAtTopoHeight, params);
-    }
-    getBlocksAtHeight(params) {
-        return this.post(RPCMethod.GetBlocksAtHeight, params);
-    }
-    getBlockByHash(params) {
-        return this.post(RPCMethod.GetBlockByHash, params);
-    }
-    getTopBlock(params) {
-        return this.post(RPCMethod.GetTopBlock, params);
-    }
-    submitBlock(blockTemplate) {
-        return this.post(RPCMethod.SubmitBlock, { block_template: blockTemplate });
-    }
-    getBalance(params) {
-        return this.post(RPCMethod.GetBalance, params);
-    }
-    hasBalance(params) {
-        return this.post(RPCMethod.HasBalance, params);
-    }
-    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);
-    }
-    countAssets() {
-        return this.post(RPCMethod.CountAssets);
-    }
-    countAccounts() {
-        return this.post(RPCMethod.CountAccounts);
-    }
-    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);
-    }
-    getPeers() {
-        return this.post(RPCMethod.GetPeers);
-    }
-    getMemPool() {
-        return this.post(RPCMethod.GetMempool);
-    }
-    getTips() {
-        return this.post(RPCMethod.GetTips);
-    }
-    getDAGOrder(params) {
-        return this.post(RPCMethod.GetDAGOrder, params);
-    }
-    getBlocksRangeByTopoheight(params) {
-        return this.post(RPCMethod.GetBlocksRangeByTopoheight, params);
-    }
-    getBlocksRangeByHeight(params) {
-        return this.post(RPCMethod.GetBlocksRangeByHeight, params);
-    }
-    getTransactions(txHashes) {
-        return this.post(RPCMethod.GetTransactions, { tx_hashes: txHashes });
-    }
-    getAccountHistory(params) {
-        return this.post(RPCMethod.GetAccountHistory, params);
-    }
-    getAccountAssets(address) {
-        return this.post(RPCMethod.GetAccountAssets, { address });
-    }
-    getAccounts(params) {
-        return this.post(RPCMethod.GetAccounts, params);
-    }
-    isTxExecutedInBlock(params) {
-        return this.post(RPCMethod.IsTxExecutedInBlock, params);
-    }
-    getDevFeeThresholds() {
-        return this.post(RPCMethod.GetDevFeeThresholds);
-    }
-    getSizeOnDisk() {
-        return this.post(RPCMethod.GetSizeOnDisk);
-    }
-}
-export default RPC;

package/daemon/websocket.js

@@ -1,171 +0,0 @@
-import { RPCEvent, RPCMethod } from './types';
-import { WS as BaseWS } from '../lib/websocket';
-export class DaemonMethods {
-    constructor(ws, prefix = "") {
-        this.ws = ws;
-        this.prefix = prefix;
-    }
-    async listenEvent(event, onData) {
-        return this.ws.listenEvent(this.prefix + event, onData);
-    }
-    dataCall(method, params) {
-        return this.ws.dataCall(this.prefix + method, params);
-    }
-    onNewBlock(onData) {
-        return this.listenEvent(RPCEvent.NewBlock, onData);
-    }
-    onTransactionAddedInMempool(onData) {
-        return this.listenEvent(RPCEvent.TransactionAddedInMempool, onData);
-    }
-    onTransactionExecuted(onData) {
-        return this.listenEvent(RPCEvent.TransactionExecuted, onData);
-    }
-    onBlockOrdered(onData) {
-        return this.listenEvent(RPCEvent.BlockOrdered, onData);
-    }
-    onPeerConnected(onData) {
-        return this.listenEvent(RPCEvent.PeerConnected, onData);
-    }
-    onPeerDisconnected(onData) {
-        return this.listenEvent(RPCEvent.PeerDisconnected, onData);
-    }
-    onPeerPeerListUpdated(onData) {
-        return this.listenEvent(RPCEvent.PeerPeerListUpdated, onData);
-    }
-    onPeerPeerDisconnected(onData) {
-        return this.listenEvent(RPCEvent.PeerPeerDisconnected, onData);
-    }
-    onPeerStateUpdated(onData) {
-        return this.listenEvent(RPCEvent.PeerStateUpdated, onData);
-    }
-    onNewAsset(onData) {
-        return this.listenEvent(RPCEvent.NewAsset, onData);
-    }
-    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);
-    }
-    getHeight() {
-        return this.dataCall(RPCMethod.GetHeight);
-    }
-    getTopoHeight() {
-        return this.dataCall(RPCMethod.GetTopoHeight);
-    }
-    getStableHeight() {
-        return this.dataCall(RPCMethod.GetStableHeight);
-    }
-    getBlockTemplate(address) {
-        return this.dataCall(RPCMethod.GetBlockTemplate, { address });
-    }
-    getBlockAtTopoHeight(params) {
-        return this.dataCall(RPCMethod.GetBlockAtTopoHeight, params);
-    }
-    getBlocksAtHeight(params) {
-        return this.dataCall(RPCMethod.GetBlocksAtHeight, params);
-    }
-    getBlockByHash(params) {
-        return this.dataCall(RPCMethod.GetBlockByHash, params);
-    }
-    getTopBlock(params) {
-        return this.dataCall(RPCMethod.GetTopBlock, params);
-    }
-    submitBlock(blockTemplate) {
-        return this.dataCall(RPCMethod.SubmitBlock, { block_template: blockTemplate });
-    }
-    getBalance(params) {
-        return this.dataCall(RPCMethod.GetBalance, params);
-    }
-    hasBalance(params) {
-        return this.dataCall(RPCMethod.HasBalance, params);
-    }
-    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);
-    }
-    submitTransaction(hexData) {
-        return this.dataCall(RPCMethod.SubmitTransaction, { data: hexData });
-    }
-    getTransaction(hash) {
-        return this.dataCall(RPCMethod.GetTransaction, { hash });
-    }
-    p2pStatus() {
-        return this.dataCall(RPCMethod.P2PStatus);
-    }
-    getPeers() {
-        return this.dataCall(RPCMethod.GetPeers);
-    }
-    getMemPool() {
-        return this.dataCall(RPCMethod.GetMempool);
-    }
-    getTips() {
-        return this.dataCall(RPCMethod.GetTips);
-    }
-    getDAGOrder(params) {
-        return this.dataCall(RPCMethod.GetDAGOrder, params);
-    }
-    getBlocksRangeByTopoheight(params) {
-        return this.dataCall(RPCMethod.GetBlocksRangeByTopoheight, params);
-    }
-    getBlocksRangeByHeight(params) {
-        return this.dataCall(RPCMethod.GetBlocksRangeByHeight, params);
-    }
-    getTransactions(txHashes) {
-        return this.dataCall(RPCMethod.GetTransactions, { tx_hashes: txHashes });
-    }
-    getAccountHistory(params) {
-        return this.dataCall(RPCMethod.GetAccountHistory, params);
-    }
-    getAccountAssets(address) {
-        return this.dataCall(RPCMethod.GetAccountAssets, { address });
-    }
-    getAccounts(params) {
-        return this.dataCall(RPCMethod.GetAccounts, params);
-    }
-    isTxExecutedInBlock(params) {
-        return this.dataCall(RPCMethod.IsTxExecutedInBlock, params);
-    }
-    getDevFeeThresholds() {
-        return this.dataCall(RPCMethod.GetDevFeeThresholds);
-    }
-    getSizeOnDisk() {
-        return this.dataCall(RPCMethod.GetSizeOnDisk);
-    }
-}
-export class WS extends BaseWS {
-    constructor() {
-        super();
-        this.methods = new DaemonMethods(this);
-    }
-}
-export default WS;

package/lib/rpc.js

@@ -1,38 +0,0 @@
-export class RPC {
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-        this.timeout = 3000;
-    }
-    async post(method, params, headers) {
-        try {
-            const controller = new AbortController();
-            const body = JSON.stringify({ id: 1, jsonrpc: '2.0', method: method, params });
-            const timeoutId = setTimeout(() => {
-                controller.abort();
-            }, this.timeout);
-            headers = headers || new Headers();
-            headers.set(`Content-Type`, `application/json`);
-            const res = await fetch(this.endpoint, {
-                headers,
-                method: `POST`,
-                body,
-                signal: controller.signal
-            });
-            clearTimeout(timeoutId);
-            if (res.ok) {
-                const data = await res.json();
-                if (data.error) {
-                    return Promise.reject(new Error(data.error.message));
-                }
-                return Promise.resolve(data);
-            }
-            else {
-                return Promise.reject(new Error(`${res.status} - ${res.statusText}`));
-            }
-        }
-        catch (err) {
-            console.log(err);
-            return Promise.reject(err);
-        }
-    }
-}