@leofcoin/endpoint-clients 0.2.6 → 0.2.8

package/exports/direct.js

@@ -0,0 +1,146 @@
+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 chain.selectedAccount;
+    }
+    selectAccount(address) {
+        return chain.selectAccount({ address });
+    }
+    accounts() {
+        return chain.accounts;
+    }
+    hasTransactionToHandle() {
+        return chain.hasTransactionToHandle();
+    }
+    getBlock(index) {
+        return chain.getBlock(index);
+    }
+    blocks(amount) {
+        return chain.blocks.slice(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.blocks.length;
+    }
+    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;
+    }
+}
+
+export { Client as default };

package/exports/http.js

@@ -121,6 +121,8 @@ class Client {
     getNonce(address) {
         return this._fetchNumber('getNonce', { address });
     }
+    lastBlock() {
+    }
 }
 
 export { Client as default };

package/exports/index.js

@@ -1,3 +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,51 @@
+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): any;
+    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(): number;
+    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;
+}

package/exports/types/http.d.ts

@@ -47,5 +47,6 @@ export default class Client {
         accountsHolding: number;
     }>;
     getNonce(address: string): Promise<number>;
+    lastBlock(): void;
 }
 export {};

package/exports/types/index.d.ts

@@ -1,2 +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

@@ -1,8 +1,8 @@
-import socketRequestClient from 'socket-request-client';
+import SocketRequestClient from 'socket-request-client';
 export default class Client {
     url: string;
     networkVersion: string;
-    client: socketRequestClient;
+    client: SocketRequestClient;
     constructor(url?: string, networkVersion?: string);
     init(): Promise<void>;
     get pubsub(): {

package/exports/ws.js

@@ -1,4 +1,4 @@
-import socketRequestClient from 'socket-request-client';
+import SocketRequestClient from 'socket-request-client';
 
 class Client {
     url;
@@ -9,7 +9,7 @@ class Client {
         this.networkVersion = networkVersion;
     }
     async init() {
-        this.client = await socketRequestClient(this.url, this.networkVersion);
+        this.client = await new SocketRequestClient(this.url, this.networkVersion);
     }
     get pubsub() {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/endpoint-clients",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "",
   "exports": {
     ".": {
@@ -15,8 +15,13 @@
       "import": "./exports/http.js",
       "types": "./exports/types/http.d.ts"
     },
+    "./direct": {
+      "import": "./exports/direct.js",
+      "types": "./exports/types/direct.d.ts"
+    },
     "./ws.js": "./exports/ws.js",
-    "./http.js": "./exports/http.js"
+    "./http.js": "./exports/http.js",
+    "./direct.js": "./exports/direct.js"
   },
   "types": "./exports/types/index.d.ts",
   "type": "module",
@@ -41,6 +46,7 @@
     "tslib": "^2.5.0"
   },
   "dependencies": {
-    "socket-request-client": "^1.7.3"
+    "@leofcoin/utils": "^1.1.7",
+    "socket-request-client": "^1.7.5"
   }
 }

package/rollup.config.js

@@ -1,7 +1,7 @@
 import typescript from '@rollup/plugin-typescript'
 import tsConfig from './tsconfig.json' assert { type: 'json'}
 export default [{
-  input: ['./src/index.ts', './src/http.ts', './src/ws.ts'],
+  input: ['./src/index.ts', './src/http.ts', './src/ws.ts', './src/direct.ts'],
   output: {
     dir: './exports',
     format: 'es'

package/src/direct.ts

@@ -0,0 +1,165 @@
+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 chain.selectedAccount
+  }
+
+  selectAccount(address: any) {
+    return chain.selectAccount({address})
+  }
+
+  accounts() {
+    return chain.accounts
+  }
+    
+  hasTransactionToHandle() {
+    return chain.hasTransactionToHandle()
+  }
+
+  getBlock(index: number) {
+    return chain.getBlock(index)
+  }
+  blocks(amount: number) {
+    return chain.blocks.slice(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(): number {
+    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.blocks.length
+  }
+  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]) => {
+        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
+  }
+}

package/src/http.ts

@@ -145,4 +145,8 @@ export default class Client {
   getNonce(address: string) {
     return this._fetchNumber('getNonce', { address })
   }
+
+  lastBlock() {
+    
+  }
 }

package/src/index.ts

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

package/src/ws.ts

@@ -1,9 +1,9 @@
-import socketRequestClient from 'socket-request-client'
+import SocketRequestClient from 'socket-request-client'
 
 export default class Client {
   url: string
   networkVersion: string
-  client: socketRequestClient
+  client: SocketRequestClient
 
   constructor(url = 'ws://localhost:4040', networkVersion = 'leofcoin-peach') {
     this.url = url
@@ -11,7 +11,7 @@ export default class Client {
   }
 
   async init() {
-    this.client = await socketRequestClient(this.url, this.networkVersion)
+    this.client = await new SocketRequestClient(this.url, this.networkVersion)
   }
 
   get pubsub() {

package/test/index.js

@@ -1,6 +1,7 @@
 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())
@@ -8,6 +9,9 @@ try {
 
   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

@@ -26,7 +26,8 @@ export const implementations = [
   'totalBlocks',
   'totalSize',
   'totalTransactions',
-  'validators'
+  'validators',
+  'lastBlock'
 ]
 
 export const needsImplementations = (client) => {
@@ -39,5 +40,6 @@ export const needsImplementations = (client) => {
     }
     
   }
+  console.log(needs);
   return needs
 }

package/tsconfig.json

@@ -12,6 +12,5 @@
   },
   "include": [
     "./src/**/*"
-  ],
-  "exclude": ["./node_modules"]
+  ]
 }