@leofcoin/endpoint-clients 0.3.8 → 0.3.10

package/exports/direct.js

@@ -0,0 +1,157 @@
+import { formatUnits, BigNumber } from '@leofcoin/utils';
+
+class Client {
+    url;
+    networkVersion;
+    client;
+    constructor(url = 'ws://localhost:4040', networkVersion = 'leofcoin-peach') {
+        this.url = url;
+        this.networkVersion = networkVersion;
+    }
+    get pubsub() {
+        return {
+            publish: globalThis.pubsub.publish,
+            subscribe: globalThis.pubsub.subscribe
+        };
+    }
+    balances() {
+        return chain.balances;
+    }
+    async balanceOf(address, format) {
+        const balances = await chain.balances;
+        const balance = balances[address];
+        return format ? formatUnits(balance) : balance;
+    }
+    selectedAccount() {
+        return peernet.selectedAccount;
+    }
+    async selectAccount(address) {
+        try {
+            await globalThis.walletStore.put('selected-account', address);
+        }
+        catch (error) {
+            throw new Error(`couldn't set selected account`);
+        }
+    }
+    accounts() {
+        return chain.accounts;
+    }
+    hasTransactionToHandle() {
+        return chain.hasTransactionToHandle();
+    }
+    getBlock(index) {
+        return chain.getBlock(index);
+    }
+    blocks(amount) {
+        return globalThis.blockStore.values(amount);
+    }
+    sendTransaction(transaction) {
+        return chain.sendTransaction(transaction);
+    }
+    peerId() {
+        return peernet.peerId;
+    }
+    peers() {
+        return peernet.peers;
+    }
+    validators() {
+        return chain.validators;
+    }
+    lookup(name) {
+        return chain.lookup(name);
+    }
+    staticCall(contract, method, params) {
+        return chain.staticCall(contract, method, params);
+    }
+    nativeBurns() {
+        return chain.nativeBurns;
+    }
+    contracts() {
+        return chain.contracts;
+    }
+    nativeMints() {
+        return chain.nativeMints;
+    }
+    nativeToken() {
+        return chain.nativeToken;
+    }
+    nativeTransfers() {
+        return chain.nativeTransfers;
+    }
+    totalSize() {
+        return chain.totalSize;
+    }
+    totalTransactions() {
+        return chain.totalTransactions;
+    }
+    poolTransactions() {
+        return transactionPoolStore.get();
+    }
+    transactionsInPool() {
+        return transactionPoolStore.length();
+    }
+    transactionPoolSize() {
+        return transactionPoolStore.size();
+    }
+    totalBlocks() {
+        return chain.totalBlocks;
+    }
+    nativeCalls() {
+        return chain.nativeCalls;
+    }
+    participating() {
+        return chain.participating;
+    }
+    participate(address) {
+        return chain.participate(address);
+    }
+    createContractAddress(owner, code, params) {
+        return chain.createContractAddress(owner, code, params);
+    }
+    deployContract(code, params) {
+        return chain.deployContract(code, params);
+    }
+    network() {
+        return chain.network;
+    }
+    async networkStats() {
+        let accountsHolding = 0;
+        let accountsHoldingAmount = BigNumber.from(0);
+        let topHolders = [];
+        const balances = Object.entries(await chain.balances)
+            .map(([holder, amount]) => {
+            amount = BigNumber.from(amount);
+            return { holder, amount };
+        })
+            .sort((a, b) => formatUnits(b.amount.sub(a.amount)));
+        for (let { holder, amount } of balances) {
+            if (amount.gt(0)) {
+                accountsHoldingAmount = accountsHoldingAmount.add(amount);
+                accountsHolding += 1;
+                topHolders.length < 100 && topHolders.push({ holder, amount: formatUnits(amount) });
+            }
+        }
+        return {
+            version: peernet.networkVersion,
+            peers: peernet.peers.map(([id, peer]) => id),
+            accounts: await accountsStore.length(),
+            accountsHolding,
+            accountsHoldingAmount: formatUnits(accountsHoldingAmount).toString(),
+            topHolders
+        };
+    }
+    getNonce(address) {
+        return chain.getNonce(address);
+    }
+    lastBlock() {
+        return chain.lastBlock;
+    }
+    blockHashMap() {
+        return chain.blockHashMap;
+    }
+    bootstrap() {
+        return chain.blockHashMap;
+    }
+}
+
+export { Client as default };

package/exports/http.js

@@ -0,0 +1,135 @@
+class Client {
+    url;
+    networkVersion;
+    get isHttpClient() {
+        return true;
+    }
+    constructor(url, networkVersion) {
+        this.url = url;
+        this.networkVersion = networkVersion;
+    }
+    async _fetch(method, params, type = 'json') {
+        params = new URLSearchParams(params).toString();
+        const response = await fetch(`${this.url}/${method}?${params}`);
+        return response[type]();
+    }
+    async _fetchString(method, params) {
+        return String(await this._fetch(method, params, 'text'));
+    }
+    async _fetchNumber(method, params) {
+        return Number(await this._fetchString(method, params));
+    }
+    async _fetchBoolean(method, params) {
+        return Boolean((await this._fetchString(method, params)) === 'true');
+    }
+    balances() {
+        return this._fetch('balances');
+    }
+    balanceOf(address, format) {
+        return this._fetch(`balanceOf`, { address, format });
+    }
+    selectedAccount() {
+        return this._fetchString('selectedAccount');
+    }
+    selectAccount(address) {
+        return this._fetch('selectAccount', { address });
+    }
+    accounts() {
+        return this._fetch('accounts');
+    }
+    hasTransactionToHandle() {
+        return this._fetchBoolean('hasTransactionToHandle');
+    }
+    getBlock(index) {
+        return this._fetch('getBlock', { index });
+    }
+    blocks(amount) {
+        return this._fetch('blocks', { amount });
+    }
+    sendTransaction(transaction) {
+        return this._fetch('sendTransaction', transaction);
+    }
+    peerId() {
+        return this._fetchString('peerId');
+    }
+    peers() {
+        return this._fetch('peers');
+    }
+    validators() {
+        return this._fetch('validators');
+    }
+    lookup(name) {
+        return this._fetch('lookup', { name });
+    }
+    staticCall(contract, method, params) {
+        return this._fetch('staticCall', { contract, method, params });
+    }
+    nativeBurns() {
+        return this._fetchNumber('nativeBurns');
+    }
+    contracts() {
+        return this._fetch('contracts');
+    }
+    nativeMints() {
+        return this._fetchNumber('nativeMints');
+    }
+    nativeToken() {
+        return this._fetchString('nativeToken');
+    }
+    nativeTransfers() {
+        return this._fetchNumber('nativeTransfers');
+    }
+    totalSize() {
+        return this._fetchNumber('totalSize');
+    }
+    totalTransactions() {
+        return this._fetchNumber('totalTransactions');
+    }
+    poolTransactions() {
+        return this._fetch('poolTransactions');
+    }
+    transactionsInPool() {
+        return this._fetchNumber('transactionsInPool');
+    }
+    transactionPoolSize() {
+        return this._fetchNumber('transactionPoolSize');
+    }
+    totalBlocks() {
+        return this._fetchNumber('totalBlocks');
+    }
+    nativeCalls() {
+        return this._fetchNumber('nativeCalls');
+    }
+    participating() {
+        return this._fetchBoolean('participating');
+    }
+    participate(address) {
+        return this._fetch('participate', { address });
+    }
+    createContractAddress(owner, code, params) {
+        return this._fetch('createContractAddress', { owner, code, params });
+    }
+    deployContract(code, params) {
+        return this._fetch('deployContract', { code, params });
+    }
+    network() {
+        return this._fetch('network');
+    }
+    networkStats() {
+        return this._fetch('networkStats');
+    }
+    getNonce(address) {
+        return this._fetchNumber('getNonce', { address });
+    }
+    lastBlock() {
+        return this._fetch('lastBlock');
+    }
+    blockHashMap() {
+        return this._fetch('blockHashMap');
+    }
+    bootstrap() {
+        return this._fetch('blockHashMap');
+    }
+}
+
+export { Client as default };

package/exports/index.js

@@ -0,0 +1,5 @@
+export { default as ws } from './ws.js';
+export { default as http } from './http.js';
+export { default as direct } from './direct.js';
+import 'socket-request-client';
+import '@leofcoin/utils';

package/exports/types/direct.d.ts

@@ -0,0 +1,53 @@
+export default class Client {
+    url: string;
+    networkVersion: string;
+    client: any;
+    constructor(url?: string, networkVersion?: string);
+    get pubsub(): {
+        publish: any;
+        subscribe: any;
+    };
+    balances(): any;
+    balanceOf(address: string, format: boolean): Promise<any>;
+    selectedAccount(): any;
+    selectAccount(address: any): Promise<void>;
+    accounts(): any;
+    hasTransactionToHandle(): any;
+    getBlock(index: number): any;
+    blocks(amount: number): any;
+    sendTransaction(transaction: any): any;
+    peerId(): any;
+    peers(): any;
+    validators(): any;
+    lookup(name: string): any;
+    staticCall(contract: string, method: string, params: {}): any;
+    nativeBurns(): number;
+    contracts(): number;
+    nativeMints(): number;
+    nativeToken(): string;
+    nativeTransfers(): number;
+    totalSize(): number;
+    totalTransactions(): number;
+    poolTransactions(): any;
+    transactionsInPool(): any;
+    transactionPoolSize(): any;
+    totalBlocks(): number;
+    nativeCalls(): number;
+    participating(): boolean;
+    participate(address: string): {};
+    createContractAddress(owner: string, code: string, params: {}): {};
+    deployContract(code: string, params: {}): {};
+    network(): any;
+    networkStats(): Promise<{
+        version: string;
+        peers: {}[];
+        accounts: number;
+        accountsHolding: number;
+        accountsHoldingAmount: number;
+        topHolders: any[];
+    }>;
+    getNonce(address: string): any;
+    lastBlock(): any;
+    blockHashMap(): any;
+    bootstrap(): any;
+}

package/exports/types/http.d.ts

@@ -0,0 +1,54 @@
+type responseType = 'json' | 'text' | 'arrayBuffer' | 'clone' | 'formData' | 'blob';
+type networkVersion = 'peach' | string;
+export default class Client {
+    url: string;
+    networkVersion: networkVersion;
+    get isHttpClient(): boolean;
+    constructor(url: any, networkVersion: any);
+    _fetch(method: string, params?: any, type?: responseType): Promise<any>;
+    _fetchString(method: string, params?: any): Promise<string>;
+    _fetchNumber(method: string, params?: any): Promise<number>;
+    _fetchBoolean(method: string, params?: any): Promise<boolean>;
+    balances(): Promise<any>;
+    balanceOf(address: any, format: any): Promise<any>;
+    selectedAccount(): Promise<string>;
+    selectAccount(address: any): Promise<any>;
+    accounts(): Promise<any>;
+    hasTransactionToHandle(): Promise<boolean>;
+    getBlock(index: any): Promise<any>;
+    blocks(amount: any): Promise<any>;
+    sendTransaction(transaction: any): Promise<any>;
+    peerId(): Promise<string>;
+    peers(): Promise<any>;
+    validators(): Promise<any>;
+    lookup(name: any): Promise<any>;
+    staticCall(contract: any, method: any, params: any): Promise<any>;
+    nativeBurns(): Promise<number>;
+    contracts(): Promise<any>;
+    nativeMints(): Promise<number>;
+    nativeToken(): Promise<string>;
+    nativeTransfers(): Promise<number>;
+    totalSize(): Promise<number>;
+    totalTransactions(): Promise<number>;
+    poolTransactions(): Promise<any>;
+    transactionsInPool(): Promise<number>;
+    transactionPoolSize(): Promise<number>;
+    totalBlocks(): Promise<number>;
+    nativeCalls(): Promise<number>;
+    participating(): Promise<boolean>;
+    participate(address: any): Promise<any>;
+    createContractAddress(owner: any, code: any, params: any): Promise<any>;
+    deployContract(code: any, params: any): Promise<any>;
+    network(): Promise<any>;
+    networkStats(): Promise<{
+        version: string;
+        peers: {}[];
+        accounts: number;
+        accountsHolding: number;
+    }>;
+    getNonce(address: string): Promise<number>;
+    lastBlock(): Promise<any>;
+    blockHashMap(): Promise<any>;
+    bootstrap(): Promise<any>;
+}
+export {};

package/exports/types/index.d.ts

@@ -0,0 +1,3 @@
+export { default as ws } from './ws.js';
+export { default as http } from './http.js';
+export { default as direct } from './direct.js';

package/exports/types/ws.d.ts

@@ -0,0 +1,54 @@
+import ClientConnection from 'socket-request-client/connection';
+export default class Client {
+    url: string;
+    networkVersion: string;
+    client: ClientConnection;
+    constructor(url?: string, networkVersion?: string);
+    init(): Promise<void>;
+    get pubsub(): {
+        publish: (topic: string, value: any) => Promise<any>;
+        subscribe: (topic: string, cb: any) => Promise<any>;
+    };
+    request(url: string, params?: {}): Promise<any>;
+    balances(): Promise<any>;
+    balanceOf(address: string, format: boolean): Promise<any>;
+    selectedAccount(): Promise<any>;
+    selectAccount(address: any): Promise<any>;
+    accounts(): Promise<any>;
+    hasTransactionToHandle(): Promise<any>;
+    getBlock(index: number): Promise<any>;
+    blocks(amount: number): Promise<any>;
+    sendTransaction(transaction: any): Promise<any>;
+    peerId(): Promise<any>;
+    peers(): Promise<any>;
+    validators(): Promise<any>;
+    lookup(name: string): Promise<any>;
+    staticCall(contract: string, method: string, params: {}): Promise<any>;
+    nativeBurns(): Promise<number>;
+    contracts(): Promise<number>;
+    nativeMints(): Promise<number>;
+    nativeToken(): Promise<string>;
+    nativeTransfers(): Promise<number>;
+    totalSize(): Promise<number>;
+    totalTransactions(): Promise<number>;
+    poolTransactions(): Promise<any>;
+    transactionsInPool(): Promise<any>;
+    transactionPoolSize(): Promise<any>;
+    totalBlocks(): Promise<number>;
+    nativeCalls(): Promise<number>;
+    participating(): Promise<boolean>;
+    participate(address: string): {};
+    createContractAddress(owner: string, code: string, params: {}): {};
+    deployContract(code: string, params: {}): {};
+    network(): Promise<any>;
+    networkStats(): Promise<{
+        version: string;
+        peers: {}[];
+        accounts: number;
+        accountsHolding: number;
+    }>;
+    getNonce(address: string): Promise<any>;
+    lastBlock(): Promise<any>;
+    blockHashMap(): Promise<any>;
+    bootstrap(): Promise<any>;
+}

package/exports/ws.js

@@ -0,0 +1,134 @@
+import { SocketRequestClient } from 'socket-request-client';
+
+class Client {
+    url;
+    networkVersion;
+    client;
+    constructor(url = 'ws://localhost:4040', networkVersion = 'leofcoin-peach') {
+        this.url = url;
+        this.networkVersion = networkVersion;
+    }
+    async init() {
+        const client = new SocketRequestClient(this.url, this.networkVersion);
+        this.client = (await client.init());
+    }
+    get pubsub() {
+        return {
+            publish: this.client.pubsub.publish,
+            subscribe: this.client.pubsub.subscribe
+        };
+    }
+    request(url, params) {
+        return this.client.request({ url, params });
+    }
+    balances() {
+        return this.request('balances');
+    }
+    balanceOf(address, format) {
+        return this.request('balanceOf', { address, format });
+    }
+    selectedAccount() {
+        return this.request('selectedAccount');
+    }
+    selectAccount(address) {
+        return this.request('selectAccount', { address });
+    }
+    accounts() {
+        return this.request('accounts');
+    }
+    hasTransactionToHandle() {
+        return this.request('hasTransactionToHandle');
+    }
+    getBlock(index) {
+        return this.request('getBlock', { index });
+    }
+    blocks(amount) {
+        return this.request('blocks', { amount });
+    }
+    sendTransaction(transaction) {
+        return this.request('sendTransaction', transaction);
+    }
+    peerId() {
+        return this.request('peerId');
+    }
+    peers() {
+        return this.request('peers');
+    }
+    validators() {
+        return this.request('validators');
+    }
+    lookup(name) {
+        return this.request('lookup', { name });
+    }
+    staticCall(contract, method, params) {
+        return this.request('staticCall', { contract, method, params });
+    }
+    nativeBurns() {
+        return this.request('nativeBurns');
+    }
+    contracts() {
+        return this.request('contracts');
+    }
+    nativeMints() {
+        return this.request('nativeMints');
+    }
+    nativeToken() {
+        return this.request('nativeToken');
+    }
+    nativeTransfers() {
+        return this.request('nativeTransfers');
+    }
+    totalSize() {
+        return this.request('totalSize');
+    }
+    totalTransactions() {
+        return this.request('totalTransactions');
+    }
+    poolTransactions() {
+        return this.request('poolTransactions');
+    }
+    transactionsInPool() {
+        return this.request('transactionsInPool');
+    }
+    transactionPoolSize() {
+        return this.request('transactionPoolSize');
+    }
+    totalBlocks() {
+        return this.request('totalBlocks');
+    }
+    nativeCalls() {
+        return this.request('nativeCalls');
+    }
+    participating() {
+        return this.request('participating');
+    }
+    participate(address) {
+        return this.request('participate', { address });
+    }
+    createContractAddress(owner, code, params) {
+        return this.request('createContractAddress', { owner, code, params });
+    }
+    deployContract(code, params) {
+        return this.request('deployContract', { code, params });
+    }
+    network() {
+        return this.request('network');
+    }
+    networkStats() {
+        return this.request('networkStats');
+    }
+    getNonce(address) {
+        return this.request('getNonce', { address });
+    }
+    lastBlock() {
+        return this.request('lastBlock');
+    }
+    blockHashMap() {
+        return this.request('blockHashMap');
+    }
+    bootstrap() {
+        return this.request('blockHashMap');
+    }
+}
+
+export { Client as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/endpoint-clients",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "",
   "exports": {
     ".": {
@@ -23,6 +23,9 @@
     "./http.js": "./exports/http.js",
     "./direct.js": "./exports/direct.js"
   },
+  "files": [
+    "exports"
+  ],
   "types": "./exports/types/index.d.ts",
   "type": "module",
   "scripts": {

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "tabWidth": 2,
-  "semi": false,
-  "singleQuote": true,
-  "printWidth": 120,
-  "trailingComma": "none"
-}

package/rollup.config.js

@@ -1,14 +0,0 @@
-import typescript from '@rollup/plugin-typescript'
-export default [{
-  input: ['./src/index.ts', './src/http.ts', './src/ws.ts', './src/direct.ts'],
-  output: {
-    dir: './exports',
-    format: 'es'
-  },
-  plugins: [
-    typescript()
-  ],
-  external: [
-    './identity.js'
-  ]
-}]

package/src/direct.ts

@@ -1,185 +0,0 @@
-import { formatUnits, BigNumber } from '@leofcoin/utils'
-
-declare var chain
-declare var peernet
-declare var transactionPoolStore
-declare var accountsStore
-
-export default class Client {
-  url: string
-  networkVersion: string
-  client
-
-  constructor(url = 'ws://localhost:4040', networkVersion = 'leofcoin-peach') {
-    this.url = url
-    this.networkVersion = networkVersion
-  }
-
-  get pubsub() {
-    return {
-      publish: globalThis.pubsub.publish,
-      subscribe: globalThis.pubsub.subscribe
-    }
-  }
-
-  balances() {
-    return chain.balances
-  }
-
-  async balanceOf(address: string, format: boolean) {
-    const balances = await chain.balances
-    const balance = balances[address]
-    return format ? formatUnits(balance) : balance
-  }
-
-  selectedAccount() {
-    return peernet.selectedAccount
-  }
-
-  async selectAccount(address: any) {
-    try {
-      await globalThis.walletStore.put('selected-account', address)
-    } catch (error) {
-      throw new Error(`couldn't set selected account`)
-    }
-  }
-
-  accounts() {
-    return chain.accounts
-  }
-
-  hasTransactionToHandle() {
-    return chain.hasTransactionToHandle()
-  }
-
-  getBlock(index: number) {
-    return chain.getBlock(index)
-  }
-
-  blocks(amount: number) {
-    return chain.getBlocks(amount)
-  }
-
-  sendTransaction(transaction) {
-    return chain.sendTransaction(transaction)
-  }
-  peerId() {
-    return peernet.peerId
-  }
-  peers() {
-    return peernet.peers
-  }
-  validators() {
-    return chain.validators
-  }
-  lookup(name: string) {
-    return chain.lookup(name)
-  }
-
-  staticCall(contract: string, method: string, params: {}) {
-    return chain.staticCall(contract, method, params)
-  }
-  nativeBurns(): number {
-    return chain.nativeBurns
-  }
-  contracts(): number {
-    return chain.contracts
-  }
-  nativeMints(): number {
-    return chain.nativeMints
-  }
-  nativeToken(): string {
-    return chain.nativeToken
-  }
-  nativeTransfers(): number {
-    return chain.nativeTransfers
-  }
-  totalSize(): number {
-    return chain.totalSize
-  }
-  totalTransactions(): number {
-    return chain.totalTransactions
-  }
-  poolTransactions() {
-    return transactionPoolStore.get()
-  }
-  transactionsInPool() {
-    return transactionPoolStore.length()
-  }
-  transactionPoolSize() {
-    return transactionPoolStore.size()
-  }
-  totalBlocks(): number {
-    return chain.totalBlocks
-  }
-  nativeCalls(): number {
-    return chain.nativeCalls
-  }
-  participating(): boolean {
-    return chain.participating
-  }
-  participate(address: string): {} {
-    return chain.participate(address)
-  }
-  createContractAddress(owner: string, code: string, params: {}): {} {
-    return chain.createContractAddress(owner, code, params)
-  }
-  deployContract(code: string, params: {}): {} {
-    return chain.deployContract(code, params)
-  }
-  network() {
-    return chain.network
-  }
-
-  async networkStats(): Promise<{
-    version: string
-    peers: {}[]
-    accounts: number
-    accountsHolding: number
-    accountsHoldingAmount: number
-    topHolders: any[]
-  }> {
-    let accountsHolding = 0
-    let accountsHoldingAmount = BigNumber.from(0)
-    let topHolders = []
-    const balances = Object.entries(await chain.balances)
-      .map(([holder, amount]): { holder: string; amount: BigNumber } => {
-        amount = BigNumber.from(amount)
-        return { holder, amount }
-      })
-      .sort((a, b) => formatUnits(b.amount.sub(a.amount)))
-
-    for (let { holder, amount } of balances) {
-      if (amount.gt(0)) {
-        accountsHoldingAmount = accountsHoldingAmount.add(amount)
-        accountsHolding += 1
-        topHolders.length < 100 && topHolders.push({ holder, amount: formatUnits(amount) })
-      }
-    }
-
-    return {
-      version: peernet.networkVersion,
-      peers: peernet.peers.map(([id, peer]) => id),
-      accounts: await accountsStore.length(),
-      accountsHolding,
-      accountsHoldingAmount: formatUnits(accountsHoldingAmount).toString(),
-      topHolders
-    }
-  }
-
-  getNonce(address: string) {
-    return chain.getNonce(address)
-  }
-
-  lastBlock() {
-    return chain.lastBlock
-  }
-
-  blockHashMap() {
-    return chain.blockHashMap
-  }
-
-  bootstrap() {
-    return chain.blockHashMap
-  }
-}

package/src/http.ts

@@ -1,159 +0,0 @@
-// see https://developer.mozilla.org/en-US/docs/Web/API/Response#instance_methods
-type responseType = 'json' | 'text' | 'arrayBuffer' | 'clone' | 'formData' | 'blob'
-type networkVersion = 'peach' | string
-
-export default class Client {
-  url: string
-  networkVersion: networkVersion
-  get isHttpClient() {
-    return true
-  }
-
-  constructor(url, networkVersion) {
-    this.url = url
-    this.networkVersion = networkVersion
-  }
-
-  async _fetch(method: string, params?, type: responseType = 'json') {
-    params = new URLSearchParams(params).toString()
-    const response = await fetch(`${this.url}/${method}?${params}`)
-    return response[type]()
-  }
-
-  async _fetchString(method: string, params?) {
-    return String(await this._fetch(method, params, 'text'))
-  }
-
-  async _fetchNumber(method: string, params?) {
-    return Number(await this._fetchString(method, params))
-  }
-
-  async _fetchBoolean(method: string, params?) {
-    return Boolean((await this._fetchString(method, params)) === 'true')
-  }
-
-  balances() {
-    return this._fetch('balances')
-  }
-
-  balanceOf(address, format) {
-    return this._fetch(`balanceOf`, { address, format })
-  }
-
-  selectedAccount() {
-    return this._fetchString('selectedAccount')
-  }
-
-  selectAccount(address) {
-    return this._fetch('selectAccount', { address })
-  }
-
-  accounts() {
-    return this._fetch('accounts')
-  }
-
-  hasTransactionToHandle() {
-    return this._fetchBoolean('hasTransactionToHandle')
-  }
-
-  getBlock(index) {
-    return this._fetch('getBlock', { index })
-  }
-  blocks(amount) {
-    return this._fetch('blocks', { amount })
-  }
-
-  sendTransaction(transaction) {
-    return this._fetch('sendTransaction', transaction)
-  }
-  peerId() {
-    return this._fetchString('peerId')
-  }
-  peers() {
-    return this._fetch('peers')
-  }
-  validators() {
-    return this._fetch('validators')
-  }
-  lookup(name) {
-    return this._fetch('lookup', { name })
-  }
-
-  staticCall(contract, method, params) {
-    return this._fetch('staticCall', { contract, method, params })
-  }
-  nativeBurns() {
-    return this._fetchNumber('nativeBurns')
-  }
-  contracts() {
-    return this._fetch('contracts')
-  }
-  nativeMints() {
-    return this._fetchNumber('nativeMints')
-  }
-  nativeToken() {
-    return this._fetchString('nativeToken')
-  }
-  nativeTransfers() {
-    return this._fetchNumber('nativeTransfers')
-  }
-  totalSize() {
-    return this._fetchNumber('totalSize')
-  }
-  totalTransactions() {
-    return this._fetchNumber('totalTransactions')
-  }
-  poolTransactions() {
-    return this._fetch('poolTransactions')
-  }
-  transactionsInPool() {
-    return this._fetchNumber('transactionsInPool')
-  }
-  transactionPoolSize() {
-    return this._fetchNumber('transactionPoolSize')
-  }
-  totalBlocks() {
-    return this._fetchNumber('totalBlocks')
-  }
-  nativeCalls() {
-    return this._fetchNumber('nativeCalls')
-  }
-  participating() {
-    return this._fetchBoolean('participating')
-  }
-  participate(address) {
-    return this._fetch('participate', { address })
-  }
-
-  createContractAddress(owner, code, params) {
-    return this._fetch('createContractAddress', { owner, code, params })
-  }
-
-  deployContract(code, params) {
-    return this._fetch('deployContract', { code, params })
-  }
-
-  network() {
-    return this._fetch('network')
-  }
-
-  networkStats(): Promise<{ version: string; peers: {}[]; accounts: number; accountsHolding: number }> {
-    return this._fetch('networkStats')
-  }
-
-  getNonce(address: string) {
-    return this._fetchNumber('getNonce', { address })
-  }
-
-  lastBlock() {
-    return this._fetch('lastBlock')
-  }
-
-  blockHashMap() {
-    return this._fetch('blockHashMap')
-  }
-
-  bootstrap() {
-    return this._fetch('blockHashMap')
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { default as ws } from './ws.js'
-export { default as http } from './http.js'
-export { default as direct } from './direct.js'

package/src/ws.ts

@@ -1,156 +0,0 @@
-import { SocketRequestClient } from 'socket-request-client'
-import ClientConnection from 'socket-request-client/connection'
-
-export default class Client {
-  url: string
-  networkVersion: string
-  client: ClientConnection
-
-  constructor(url = 'ws://localhost:4040', networkVersion = 'leofcoin-peach') {
-    this.url = url
-    this.networkVersion = networkVersion
-  }
-
-  async init() {
-    const client = new SocketRequestClient(this.url, this.networkVersion)
-    this.client = (await client.init()) as ClientConnection
-  }
-
-  get pubsub() {
-    return {
-      publish: this.client.pubsub.publish,
-      subscribe: this.client.pubsub.subscribe
-    }
-  }
-
-  request(url: string, params?: {}) {
-    return this.client.request({ url, params })
-  }
-
-  balances() {
-    return this.request('balances')
-  }
-
-  balanceOf(address: string, format: boolean) {
-    return this.request('balanceOf', { address, format })
-  }
-
-  selectedAccount() {
-    return this.request('selectedAccount')
-  }
-
-  selectAccount(address: any) {
-    return this.request('selectAccount', { address })
-  }
-
-  accounts() {
-    return this.request('accounts')
-  }
-
-  hasTransactionToHandle() {
-    return this.request('hasTransactionToHandle')
-  }
-
-  getBlock(index: number) {
-    return this.request('getBlock', { index })
-  }
-  blocks(amount: number) {
-    return this.request('blocks', { amount })
-  }
-
-  sendTransaction(transaction) {
-    return this.request('sendTransaction', transaction)
-  }
-  peerId() {
-    return this.request('peerId')
-  }
-  peers() {
-    return this.request('peers')
-  }
-  validators() {
-    return this.request('validators')
-  }
-  lookup(name: string) {
-    return this.request('lookup', { name })
-  }
-
-  staticCall(contract: string, method: string, params: {}) {
-    return this.request('staticCall', { contract, method, params })
-  }
-  nativeBurns(): Promise<number> {
-    return this.request('nativeBurns')
-  }
-  contracts(): Promise<number> {
-    return this.request('contracts')
-  }
-  nativeMints(): Promise<number> {
-    return this.request('nativeMints')
-  }
-  nativeToken(): Promise<string> {
-    return this.request('nativeToken')
-  }
-  nativeTransfers(): Promise<number> {
-    return this.request('nativeTransfers')
-  }
-  totalSize(): Promise<number> {
-    return this.request('totalSize')
-  }
-  totalTransactions(): Promise<number> {
-    return this.request('totalTransactions')
-  }
-  poolTransactions() {
-    return this.request('poolTransactions')
-  }
-  transactionsInPool() {
-    return this.request('transactionsInPool')
-  }
-  transactionPoolSize() {
-    return this.request('transactionPoolSize')
-  }
-  totalBlocks(): Promise<number> {
-    return this.request('totalBlocks')
-  }
-  nativeCalls(): Promise<number> {
-    return this.request('nativeCalls')
-  }
-  participating(): Promise<boolean> {
-    return this.request('participating')
-  }
-  participate(address: string): {} {
-    return this.request('participate', { address })
-  }
-  createContractAddress(owner: string, code: string, params: {}): {} {
-    return this.request('createContractAddress', { owner, code, params })
-  }
-  deployContract(code: string, params: {}): {} {
-    return this.request('deployContract', { code, params })
-  }
-  network() {
-    return this.request('network')
-  }
-
-  networkStats(): Promise<{
-    version: string
-    peers: {}[]
-    accounts: number
-    accountsHolding: number
-  }> {
-    return this.request('networkStats')
-  }
-
-  getNonce(address: string) {
-    return this.request('getNonce', { address })
-  }
-
-  lastBlock() {
-    return this.request('lastBlock')
-  }
-
-  blockHashMap() {
-    return this.request('blockHashMap')
-  }
-
-  bootstrap() {
-    return this.request('blockHashMap')
-  }
-}

package/test/index.js

@@ -1,17 +0,0 @@
-import { needsImplementations } from './spec.js';
-import WsClient from './../exports/ws.js'
-import HttpClient from './../exports/http.js'
-import DirectClient from './../exports/direct.js'
-
-try {
-  const wsNeeds = needsImplementations(new WsClient())
-  if (wsNeeds.length > 0) throw new Error(`ws: missing implementations ${wsNeeds.length > 2 ? wsNeeds.join(', ') : wsNeeds.join(' & ')}`)
-
-  const httpNeeds = needsImplementations(new HttpClient())
-  if (httpNeeds.length > 0) throw new Error(`http: missing implementations ${httpNeeds.length > 2 ? httpNeeds.join(', ') : httpNeeds.join(' & ')}`)
-
-  const directNeeds = needsImplementations(new DirectClient())
-  if (directNeeds.length > 0) throw new Error(`direct: missing implementations ${directNeeds.length > 2 ? directNeeds.join(', ') : directNeeds.join(' & ')}`)
-} catch (error) {
-  console.error(error);
-}

package/test/spec.js

@@ -1,45 +0,0 @@
-export const implementations = [
-  'accounts',
-  'balanceOf',
-  'balances',
-  'blocks',
-  'contracts',
-  'createContractAddress',
-  'createTransactionFrom',
-  'deployContract',
-  'getBlock',
-  'hasTransactionToHandle',
-  'lookup',
-  'nativeBurns',
-  'nativeCalls',
-  'nativeMints',
-  'nativeToken',
-  'nativeTransfers',
-  'participate',
-  'participating',
-  'peerId',
-  'peers',
-  'pubsub',
-  'selectAccount',
-  'selectedAccount',
-  'staticCall',
-  'totalBlocks',
-  'totalSize',
-  'totalTransactions',
-  'validators',
-  'lastBlock'
-]
-
-export const needsImplementations = (client) => {
-  const needs = []
-  for (const key of implementations)  {
-    try {
-      if (!client[key] && key === 'pubsub' && !client.isHttpClient) needs.push(key)  
-    } catch (error) {
-      if (error.message !== "Cannot read properties of undefined (reading 'pubsub')") throw new Error(error)
-    }
-    
-  }
-  console.log(needs);
-  return needs
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "target": "es2022",
-    "outDir": "./exports",
-    "moduleResolution":"NodeNext",
-    "allowJs": true,
-    "declaration": true,
-    "declarationDir": "./exports/types",
-    "allowSyntheticDefaultImports": true,    
-    "resolveJsonModule": true
-  },
-  "include": [
-    "./src/**/*"
-  ]
-}