@leofcoin/endpoints 0.1.4 → 0.2.1

package/exports/api.md

@@ -0,0 +1,188 @@
+#### selectAccount(address: `string`)
+`address`: desired address
+> set default account to given address
+```js
+await client.selectAccount(address)
+```
+<br>
+
+#### getBlock(index: `number`)
+`index`: index of the block to fetch<br>
+```js
+await client.getBlock(10)
+```
+<br>
+
+#### blocks(amount)
+`amount`: the amount to slice
+```js
+await client.blocks(-25)
+```
+<br>
+
+#### createTransactionFrom(from: `string`, to: `string`, method: `string`, parameters: `array`, nonce: `number` | `undefined`)
+
+`from`:<br>
+`to`: <br>
+`method`: <br>
+`parameters`: <br>
+`nonce`: <br>
+```js
+await client.createTransactionFrom(from, to, method, parameters, nonce)
+```
+<br>
+
+#### lookup(name: `string`)
+`name`: name of the contract to lookup the address and owner of
+```js
+await client.lookup('contractName')
+```
+<br>
+
+#### participate(address: `string`)
+`address`: <br>
+
+```js
+await client.participate(address)
+```
+<br>
+
+#### staticCall(contract: `string`, method: `string`, params: `array`)
+`contract`: contract address todo the call on
+`method`: method/function to call
+`params`: array containing params needed to call the desired method 
+```js
+await client.staticCall(contract, method, params)
+```
+<br>
+
+#### createContractAddress(owner: `string`, code: `string`, params: `array`)
+`owner`: address of the deployer<br>
+`code`: contract as a string<br>
+`params`: contract constructor params<br>
+
+```js
+const address = await client.createContractAddress(owner, code, params)
+```
+<br>
+
+#### deployContract(code: `string`, params: `array`)
+`code`: contract as a string<br>
+`params`: contract constructor params<br>
+
+```js
+const tx = await client.deployContract(code, params)
+```
+<br>
+
+#### accounts() 
+```js
+await client.accounts()
+```
+<br>
+
+#### hasTransactionToHandle() 
+```js
+await client.hasTransactionToHandle()
+```
+<br>
+
+#### balances()
+> returns all balances
+```js
+await client.balances()
+```
+<br>
+
+#### balancOf(address: `string`, format: `boolean`)
+`address`: The address to check<br> 
+`format`: Wether or not to format<br>
+> returns the balance of given address as BigNumber or string (when format is true)
+```js
+await client.balanceOf(address, true)
+```
+<br>
+
+#### selectedAccount()
+```js
+await client.selectedAccount()
+```
+<br>
+
+#### peerId()
+```js
+await client.peerId()
+```
+<br>
+
+#### peers() 
+```js
+await client.peers()
+```
+<br>
+
+#### validators() 
+```js
+await client.validators()
+```
+<br>
+
+#### nativeBurns()
+```js
+await client.nativeBurns()
+```
+<br>
+
+#### contracts()
+```js
+await client.contracts()
+```
+<br>
+
+#### nativeMints()
+```js
+await client.nativeMints()
+```
+<br>
+
+#### nativeToken()
+```js
+await client.nativeToken()
+```
+<br>
+
+#### nativeTransfers()
+```js
+await client.  nativeTransfers()
+```
+<br>
+
+#### totalSize()
+```js
+await client.totalSize()
+```
+<br>
+
+#### totalTransactions()
+```js
+await client.totalTransactions()
+```
+<br>
+
+#### totalBlocks()
+```js
+await client.totalBlocks()
+```
+<br>
+
+#### nativeCalls()
+```js
+await client.nativeCalls()
+```
+<br>
+
+#### participating()
+```js
+await client.participating()
+```
+<br>

package/exports/http.js

@@ -2,11 +2,21 @@ import koa from 'koa'
 import cors from '@koa/cors'
 import Router from '@koa/router'
 import {formatUnits} from '@leofcoin/utils'
+import {readFile} from 'fs/promises'
+import Showdown from 'showdown'
 
 const api = new koa()
 const router = new Router()
 
+const converter = new showdown.Converter()
+const apiFile = await readFile('./api.md')
+
 export default (chain, port, networkVersion) => {
+  // api routes
+  router.get('/', ctx => {
+    ctx.body = converter.makeHtml(apiFile.toString())
+  })
+
   router.get('/network', ctx => {
     ctx.body = networkVersion
   })
@@ -30,12 +40,95 @@ export default (chain, port, networkVersion) => {
     return
   })
 
+  router.get('/accounts', async ctx => {
+    ctx.body = JSON.parse(new TextDecoder().decode((await walletStore.get('accounts'))))
+  })
+
+  router.get('/hasTransactionToHandle', async ctx => {
+    ctx.body = await chain.hasTransactionToHandle()
+  })
+  router.get('/getBlock', ctx => ctx.body = chain.blocks[ctx.query.index])
+
+  router.get('/blocks', ctx => {
+    ctx.body = chain.blocks.slice(ctx.query.amount)
+  })
+
+  router.get('/createTransactionFrom', async ctx => {
+    try {
+      const tx = await chain.createTransactionFrom(ctx.query.from, ctx.query.to, ctx.query.method, ctx.query.parameters, ctx.query.nonce)
+      await tx.wait()
+      send(tx)
+    } catch (error) {
+      send(202)
+    }
+  })
+
+  router.get('/peerId', ctx => 
+    ctx.body = peernet.peerId
+  )
+
+  router.get('/validators', ctx => 
+    ctx.body = chain.validators
+  )
+
+  router.get('/lookup', ctx => 
+    ctx.body = chain.lookup(ctx.query.name)
+  )
+  
+  router.get('/staticCall', async ctx => 
+    ctx.body = await chain.staticCall(ctx.query.contract, ctx.query.method, ctx.query.params)
+  )
+  
+  router.get('/nativeBurns', ctx => 
+    ctx.body = chain.nativeBurns
+  )
+
+  router.get('/contracts', ctx => 
+    ctx.body = chain.contracts
+  )
+  
+  router.get('/nativeMints', ctx => 
+    ctx.body = chain.nativeMints
+  )
+
+  router.get('/nativeToken', ctx => 
+    ctx.body = chain.nativeToken
+  )
+
+  router.get('/nativeTransfers', ctx =>
+    ctx.body = chain.nativeTransfers
+  )
+
+  router.get('/totalSize', ctx => 
+    ctx.body = chain.totalSize
+  )
+    
+  router.get('/totalTransactions', ctx => 
+    ctx.body = chain.totalTransactions
+  )
+
+  router.get('/totalBlocks', ctx => 
+    ctx.body = chain.blocks.length
+  )  
+    
+  router.get('/nativeCalls', ctx => 
+    ctx.body = chain.nativeCalls
+  )
+  
+  router.get('/participating', ctx =>
+    ctx.body = chain.participating
+  )
+
+  router.get('participate', async ctx =>
+    ctx.body = await chain.participate(ctx.query.address)
+  )
+
   router.get('/deployContract', async ctx => {
     try {
       const tx = await chain.deployContract(ctx.query.code, ctx.query.params)
       await tx.wait()
       delete tx.wait
-      ctx.body = tx
+      ctx.body = JSON.stringify(tx)
     } catch (error) {
       
     }

package/exports/ws.js

@@ -38,7 +38,7 @@ export default (chain, port, protocol) => {
     peerId: ({send}) =>
       send(peernet.peerId),
     peers: ({send}) =>
-      send(node.peers),
+      send(peernet.peers),
     validators: ({send}) => 
       send(chain.validators),
     lookup: async ({name}, {send}) => 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/endpoints",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "",
   "type": "module",
   "exports": {
@@ -26,6 +26,7 @@
     "@koa/router": "^12.0.0",
     "@leofcoin/utils": "^1.1.5",
     "koa": "^2.14.1",
+    "showdown": "^2.1.0",
     "socket-request-server": "^1.6.3"
   }
 }

package/rollup.config.js

@@ -0,0 +1,30 @@
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import wasm from '@rollup/plugin-wasm'
+import rimraf from 'rimraf'
+
+rimraf.sync('./exports/**')
+
+
+export default [{
+  input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/browser-store.js'],
+  output: {
+    format: 'es',
+    dir: './exports/browser'
+  },
+  plugins: [
+    json(),
+    wasm(),
+    commonjs(),
+    resolve({
+      mainFields: ["browser", "module", "main"]
+    })
+  ]
+}, {
+  input: ['./src/peernet.ts', './node_modules/@leofcoin/storage/exports/store.js'],
+  output: {
+    format: 'es',
+    dir: './exports'
+  }
+}]

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "module": "ES2022",
+    "target": "es2022",
+    // "noImplicitAny": true,
+    "removeComments": true,
+    "preserveConstEnums": true,
+    "outDir": ".build/",
+    "moduleResolution":"NodeNext",
+    "sourceMap": true,
+    "allowJs": true
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": ["node_modules"]
+}