@leofcoin/endpoints 0.3.1 → 0.3.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 vandeurenglenn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2022 vandeurenglenn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/exports/http.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * ensure remote is set to false when serving on a server
+ */
+declare const _default: (chain: any, port: any, networkVersion: any, remote?: boolean) => void;
+export default _default;

package/exports/http.js

@@ -1,193 +1,144 @@
-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'
-import shared from './shared.js'
-import { dirname, join} from 'path'
-import { fileURLToPath } from 'url'
-
+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';
+import shared from './shared.js';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-
-const api = new koa()
-const router = new Router()
-
-const converter = new Showdown.Converter()
-const apiFile = await readFile(join(__dirname, './api.md'))
-
-export default (chain, port, networkVersion) => {
-  // api routes
-  router.get('/', ctx => {
-    ctx.body = converter.makeHtml(apiFile.toString())
-  })
-
-  router.get('/network', ctx => {
-    ctx.body = {
-      version: networkVersion
-    }
-  })
-
-  router.get('/networkStats', async ctx => {
-    ctx.body = await shared.networkStats(chain, networkVersion)
-  })
-
-  router.get('/balances', async ctx => {
-    ctx.body = await chain.balances
-  })
-
-  router.get('/balanceOf', async ctx => {
-    const balance = (await chain.balances)[ctx.query.address]
-    if (balance) ctx.body = ctx.query.format ? formatUnits(balance) : balance
-    else ctx.body = 0
-  })
-  
-  router.get('/selectedAccount', ctx => ctx.body = peernet.selectedAccount)
-
-  router.get('/selectAccount', async ctx => {
-    try {
-      await walletStore.put('selected-account', address)  
-    } catch (error) {
-    }
-    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('/getNonce', async ctx => {
-    ctx.body = await chain.getNonce(ctx.query.address)
-  })
-
-  router.get('/getBlock', ctx => ctx.body = chain.blocks[ctx.query.index - 1])
-
-  router.get('/blocks', ctx => {
-    ctx.body = chain.blocks.slice(ctx.query.amount)
-  })
-
-  router.get('/sendTransaction', async ctx => {
-    try {      
-      const tx = await chain.sendTransaction(ctx.query.transaction)
-      await tx.wait()
-      delete tx.wait
-      ctx.body = tx
-    } catch (error) {
-      // ctx(202)
-    }
-  })
-
-  router.get('/peerId', ctx => 
-    ctx.body = peernet.peerId
-  )
-
-  router.get('/validators', ctx => 
-    ctx.body = chain.validators
-  )
-
-  router.get('/peers', ctx => 
-    ctx.body = peernet.peers.map(([id, peer]) => id)
-  )  
-
-  router.get('/lookup', async ctx => {
-    ctx.body = await 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('/poolTransactions', async ctx =>
-    ctx.body = await transactionPoolStore.get()
-  )
-    router.get('/transactionsInPool', async ctx => 
-    ctx.body = await transactionPoolStore.length()
-  )
-    router.get('/transactionPoolSize', async ctx => 
-    ctx.body = await transactionPoolStore.size()
-  )
-
-  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 = JSON.stringify(tx)
-    } catch (error) {
-      
-    }
-  })
-  
-  router.get('/createContractAddress', async ctx => {
-    try {
-      const address = await chain.createContractAddress(ctx.query.owner, ctx.query.code, ctx.query.params)
-      ctx.body = address
-    } catch (error) {
-      
-    }
-  })
-
-  router.get('/lastBlock', async ctx => ctx.body = chain.lastBlock)
-
-  router.get('/blockHashMap', async ctx => ctx.body = chain.blockHashMap)
-
-  router.get('/bootstrap', async ctx => {
-    ctx.body = (await shared.bootstrap()).map(value => Array.from(value.toString()))
-  })
-
-  // todo finish ...
-  api.use(cors('*'))
-  api.use(router.routes())
-  api.listen(port)
-}
-
-
+const api = new koa();
+const router = new Router();
+const converter = new Showdown.Converter();
+const apiFile = await readFile(join(__dirname, './api.md'));
+/**
+ *
+ * ensure remote is set to false when serving on a server
+ */
+export default (chain, port, networkVersion, remote = false) => {
+    // api routes
+    router.get('/', (ctx) => {
+        ctx.body = converter.makeHtml(apiFile.toString());
+    });
+    router.get('/network', (ctx) => {
+        ctx.body = {
+            version: networkVersion
+        };
+    });
+    router.get('/networkStats', async (ctx) => {
+        ctx.body = await shared.networkStats(chain, networkVersion);
+    });
+    router.get('/balances', async (ctx) => {
+        ctx.body = await chain.balances;
+    });
+    router.get('/balanceOf', async (ctx) => {
+        // @ts-ignore
+        const balance = (await chain.balances)[ctx.query.address];
+        if (balance)
+            ctx.body = ctx.query.format ? formatUnits(balance) : balance;
+        else
+            ctx.body = 0;
+    });
+    router.get('/selectedAccount', (ctx) => {
+        if (remote)
+            ctx.body = globalThis.peernet.selectedAccount;
+        else
+            ctx.status = 405;
+    });
+    router.get('/selectAccount', async (ctx) => {
+        if (remote) {
+            globalThis.peernet.selectedAccount = ctx.query.address;
+            try {
+                await globalThis.walletStore.put('selected-account', ctx.query.address);
+            }
+            catch (error) {
+                ctx.body = error.message;
+            }
+        }
+        else {
+            ctx.status = 405;
+        }
+    });
+    router.get('/accounts', async (ctx) => {
+        if (remote)
+            ctx.body = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('accounts')));
+        else
+            ctx.status = 405;
+    });
+    router.get('/hasTransactionToHandle', async (ctx) => {
+        ctx.body = await chain.hasTransactionToHandle();
+    });
+    router.get('/getNonce', async (ctx) => {
+        ctx.body = await chain.getNonce(ctx.query.address);
+    });
+    router.get('/getBlock', async (ctx) => (ctx.body = await chain.getBlock(ctx.query.index)));
+    router.get('/blocks', async (ctx) => {
+        ctx.body = chain.getBlocks(ctx.query.amount);
+    });
+    router.get('/sendTransaction', async (ctx) => {
+        try {
+            const tx = await chain.sendTransaction(ctx.query.transaction);
+            await tx.wait();
+            delete tx.wait;
+            ctx.body = tx;
+        }
+        catch (error) {
+            // ctx(202)
+        }
+    });
+    router.get('/peerId', (ctx) => (ctx.body = globalThis.peernet.peerId));
+    router.get('/validators', (ctx) => (ctx.body = chain.validators));
+    router.get('/peers', (ctx) => (ctx.body = globalThis.peernet.peers.map(([id, peer]) => id)));
+    router.get('/lookup', async (ctx) => {
+        ctx.body = await 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', async (ctx) => (ctx.body = await chain.nativeBurns));
+    router.get('/contracts', async (ctx) => (ctx.body = await chain.contracts));
+    router.get('/nativeMints', async (ctx) => (ctx.body = await chain.nativeMints));
+    router.get('/nativeToken', async (ctx) => (ctx.body = await chain.nativeToken));
+    router.get('/nativeTransfers', async (ctx) => (ctx.body = await chain.nativeTransfers));
+    router.get('/totalSize', async (ctx) => (ctx.body = await chain.totalSize));
+    router.get('/totalTransactions', async (ctx) => (ctx.body = await chain.totalTransactions));
+    router.get('/totalBlocks', async (ctx) => (ctx.body = await chain.totalBlocks));
+    router.get('/nativeCalls', async (ctx) => (ctx.body = await chain.nativeCalls));
+    router.get('/lastBlock', async (ctx) => (ctx.body = await chain.lastBlock));
+    router.get('/poolTransactions', async (ctx) => (ctx.body = await globalThis.transactionPoolStore.get()));
+    router.get('/transactionsInPool', async (ctx) => (ctx.body = await globalThis.transactionPoolStore.length()));
+    router.get('/transactionPoolSize', async (ctx) => (ctx.body = await globalThis.transactionPoolStore.size()));
+    router.get('/participating', (ctx) => (ctx.body = chain.participating));
+    router.get('/participate', async (ctx) => {
+        if (remote)
+            ctx.body = await chain.participate(ctx.query.address);
+        else
+            ctx.status = 405;
+    });
+    router.get('/deployContract', async (ctx) => {
+        try {
+            const tx = await chain.deployContract(ctx.query.contract, ctx.query.transaction);
+            await tx.wait();
+            delete tx.wait;
+            ctx.body = JSON.stringify(tx);
+        }
+        catch (error) {
+            ctx.body = error.mesage;
+        }
+    });
+    router.get('/createContractAddress', async (ctx) => {
+        try {
+            const address = await chain.createContractAddress(ctx.query.owner, ctx.query.code, ctx.query.params);
+            ctx.body = address;
+        }
+        catch (error) { }
+    });
+    router.get('/blockHashMap', async (ctx) => (ctx.body = chain.blockHashMap));
+    router.get('/bootstrap', async (ctx) => {
+        ctx.body = (await shared.bootstrap()).map((value) => Array.from(value.toString()));
+    });
+    // todo finish ...
+    api.use(cors({ origin: '*' }));
+    api.use(router.routes());
+    api.listen(port);
+};

package/exports/shared.d.ts

@@ -0,0 +1,20 @@
+export declare const networkStats: (chain: any, networkVersion: any) => Promise<{
+    version: any;
+    peers: any;
+    accounts: any;
+    accountsHolding: number;
+    accountsHoldingAmount: string;
+    topHolders: any[];
+}>;
+declare const _default: {
+    networkStats: (chain: any, networkVersion: any) => Promise<{
+        version: any;
+        peers: any;
+        accounts: any;
+        accountsHolding: number;
+        accountsHoldingAmount: string;
+        topHolders: any[];
+    }>;
+    bootstrap: () => Promise<any>;
+};
+export default _default;

package/exports/shared.js

@@ -1,39 +1,38 @@
-import {formatUnits, BigNumber} from '@leofcoin/utils'
-
+import { formatUnits, BigNumber } from '@leofcoin/utils';
 export const networkStats = async (chain, networkVersion) => {
-  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}
+    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)})
+        // @ts-ignore
+        .sort((a, b) => formatUnits(b.amount.sub(a.amount)));
+    for (let { holder, amount } of balances) {
+        // @ts-ignore
+        if (amount.gt(0)) {
+            // @ts-ignore
+            accountsHoldingAmount = accountsHoldingAmount.add(amount);
+            accountsHolding += 1;
+            // @ts-ignore
+            topHolders.length < 100 && topHolders.push({ holder, amount: formatUnits(amount) });
+        }
     }
-  }
-  
-  return {
-    version: networkVersion,
-    peers: peernet.peers.map(([id, peer]) => id),
-    accounts: await accountsStore.length(),
-    accountsHolding,
-    accountsHoldingAmount: formatUnits(accountsHoldingAmount).toString(),
-    topHolders
-  }
-}
-
+    return {
+        version: networkVersion,
+        peers: globalThis.peernet.peers.map(([id, peer]) => id),
+        accounts: await globalThis.accountsStore.length(),
+        accountsHolding,
+        accountsHoldingAmount: formatUnits(accountsHoldingAmount).toString(),
+        topHolders
+    };
+};
 const bootstrap = async () => {
-  return blockStore.values()
-}
-
+    return globalThis.blockStore.values();
+};
 export default {
-  networkStats,
-  bootstrap
-}
+    networkStats,
+    bootstrap
+};

package/exports/ws.d.ts

@@ -0,0 +1,5 @@
+declare const _default: (chain: any, port: any, networkVersion: any, remote?: boolean) => Promise<{
+    close: () => any;
+    connections: any[];
+}>;
+export default _default;

package/exports/ws.js

@@ -1,114 +1,111 @@
-import Server from 'socket-request-server'
-import {formatUnits} from '@leofcoin/utils'
-import shared from './shared.js'
-
-export default (chain, port, networkVersion) => {
-  return Server({ port, protocol: networkVersion }, {
-    network: async () => {
-      send({version: networkVersion})
-    },
-    networkStats: async ({send}) => {
-      send(await shared.networkStats(chain, networkVersion))
-    },
-    balances: async ({send}) => 
-      send(await chain.balances),
-    balanceOf: async ({address, format = false}, {send}) => {
-      const balance = (await chain.balances)[address]
-      if (balance) send(format ? formatUnits(balance) : balance)
-      else send(0)
-    },
-    getNonce: async ({address}, {send}) => send(await chain.getNonce(address)),
-    selectedAccount: ({send}) => send(peernet.selectedAccount),
-    selectAccount: async ({address}, {send}) => {
-      try {
-        await walletStore.put('selected-account', address)  
-        send(200)
-      } catch (error) {
-        send(404)
-      }    
-    },
-    accounts: async ({send}) => 
-      send(JSON.parse(new TextDecoder().decode((await walletStore.get('accounts'))))),
-    hasTransactionToHandle: async ({send}) => 
-      send(await chain.hasTransactionToHandle()),
-    getBlock: ({index}, {send}) => 
-      send(chain.blocks[index - 1]),
-    blocks:({amount}, {send}) => {
-      send(chain.blocks.slice(amount))},
-    sendTransaction: async (transaction, {send}) => {      
-      try {
-        const tx = await chain.sendTransaction(transaction)
-        await tx.wait()
-        delete tx.wait
-        send(tx)
-      } catch (error) {
-        send(202)
-      }
-    },  
-    peerId: ({send}) =>
-      send(peernet.peerId),
-    peers: ({send}) =>
-      send(peernet.peers.map(([id, peer]) => id)),
-    validators: ({send}) => 
-      send(chain.validators),
-    lookup: async ({name}, {send}) => 
-      send(await chain.lookup(name)),
-    staticCall: async({contract, method, params}, {send}) => 
-      send(await chain.staticCall(contract, method, params)),
-    nativeBurns: ({send}) => 
-      send(chain.nativeBurns),
-    contracts: ({send}) => 
-      send(chain.contracts),
-    nativeMints: ({send}) => 
-      send(chain.nativeMints),
-    nativeToken: ({send}) => 
-      send(chain.nativeToken),
-    nativeTransfers: ({send}) => 
-      send(chain.nativeTransfers),
-    totalSize: ({send}) => 
-      send(chain.totalSize),
-    totalTransactions: ({send}) => 
-      send(chain.totalTransactions),
-    poolTransactions: async ({send}) =>
-      send(await transactionPoolStore.get()),
-    transactionsInPool: async ({send}) => 
-      send(await transactionPoolStore.length()),
-    transactionPoolSize: async ({send}) => 
-      send(await transactionPoolStore.size()),
-    totalBlocks: ({send}) => 
-      send(chain.blocks.length),  
-    nativeCalls: ({send}) => 
-      send(chain.nativeCalls),  
-    participating: ({send}) =>
-      send(chain.participating),
-    participate: async ({address}, {send}) =>
-      send(await chain.participate(address)),
-    deployContract: async ({code, params}, {send}) => {
-      try {
-        const tx = await chain.deployContract(code, params)
-        await tx.wait()
-        delete tx.wait
-        send(tx)
-      } catch (error) {
-        send(error.message)
-      }
-    },      
-    createContractAddress: async ({owner, code, params}, {send}) => {
-      try {
-        const address = await chain.createContractAddress(owner, code, params)
-        send(address)
-      } catch (error) {
-        send(error)
-      }      
-    },
-    
-    lastBlock: async ctx => ctx.body = chain.lastBlock,
-
-    blockHashMap: async ctx => ctx.body = chain.blockHashMap,
-
-    bootstrap: async ({send}) => {
-      send(await shared.bootstrap())
-    } 
-  })  
-}
-
+import Server from 'socket-request-server';
+import { formatUnits } from '@leofcoin/utils';
+import shared from './shared.js';
+export default (chain, port, networkVersion, remote = false) => {
+    return Server({ port, protocol: networkVersion }, {
+        network: async ({ send }) => {
+            send({ version: networkVersion });
+        },
+        networkStats: async ({ send }) => {
+            send(await shared.networkStats(chain, networkVersion));
+        },
+        balances: async ({ send }) => send(await chain.balances),
+        balanceOf: async ({ address, format = false }, { send }) => {
+            const balance = (await chain.balances)[address];
+            if (balance)
+                send(format ? formatUnits(balance) : balance);
+            else
+                send(0);
+        },
+        getNonce: async ({ address }, { send }) => send(await chain.getNonce(address)),
+        selectedAccount: ({ send }) => {
+            if (remote)
+                send(globalThis.peernet.selectedAccount);
+            else
+                send(405);
+        },
+        selectAccount: async ({ address }, { send }) => {
+            if (remote)
+                try {
+                    await globalThis.walletStore.put('selected-account', address);
+                    send(200);
+                }
+                catch (error) {
+                    send(404);
+                }
+            else
+                send(405);
+        },
+        accounts: async ({ send }) => {
+            if (remote)
+                send(JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('accounts'))));
+            else
+                send(405);
+        },
+        hasTransactionToHandle: async ({ send }) => send(await chain.hasTransactionToHandle()),
+        getBlock: async ({ index }, { send }) => send(await chain.getBlock(index)),
+        blocks: async ({ amount }, { send }) => {
+            send(await chain.getBlocks(amount));
+        },
+        sendTransaction: async (transaction, { send }) => {
+            try {
+                const tx = await chain.sendTransaction(transaction);
+                await tx.wait();
+                delete tx.wait;
+                send(tx);
+            }
+            catch (error) {
+                send(202);
+            }
+        },
+        peerId: ({ send }) => send(globalThis.peernet.peerId),
+        peers: ({ send }) => send(globalThis.peernet.peers.map(([id, peer]) => id)),
+        validators: ({ send }) => send(chain.validators),
+        lookup: async ({ name }, { send }) => send(await chain.lookup(name)),
+        staticCall: async ({ contract, method, params }, { send }) => send(await chain.staticCall(contract, method, params)),
+        nativeBurns: async ({ send }) => send(await chain.nativeBurns),
+        contracts: async ({ send }) => send(await chain.contracts),
+        nativeMints: async ({ send }) => send(await chain.nativeMints),
+        nativeToken: async ({ send }) => send(await chain.nativeToken),
+        nativeTransfers: async ({ send }) => send(await chain.nativeTransfers),
+        totalSize: async ({ send }) => send(await chain.totalSize),
+        totalTransactions: async ({ send }) => send(await chain.totalTransactions),
+        totalBlocks: async ({ send }) => send(chain.totalBlocks),
+        lastBlock: async (ctx) => (ctx.body = await chain.lastBlock),
+        nativeCalls: async ({ send }) => send(await chain.nativeCalls),
+        participating: async ({ send }) => send(await chain.participating),
+        poolTransactions: async ({ send }) => send(await globalThis.transactionPoolStore.get()),
+        transactionsInPool: async ({ send }) => send(await globalThis.transactionPoolStore.length()),
+        transactionPoolSize: async ({ send }) => send(await globalThis.transactionPoolStore.size()),
+        participate: async ({ address }, { send }) => {
+            if (remote)
+                send(await chain.participate(address));
+            else
+                send(405);
+        },
+        deployContract: async ({ transaction, contract }, { send }) => {
+            try {
+                const tx = await chain.deployContract(contract, transaction);
+                await tx.wait();
+                delete tx.wait;
+                send(tx);
+            }
+            catch (error) {
+                send(error.message);
+            }
+        },
+        createContractAddress: async ({ owner, code, params }, { send }) => {
+            try {
+                const address = await chain.createContractAddress(owner, code, params);
+                send(address);
+            }
+            catch (error) {
+                send(error);
+            }
+        },
+        blockHashMap: async (ctx) => (ctx.body = chain.blockHashMap),
+        bootstrap: async ({ send }) => {
+            send(await shared.bootstrap());
+        }
+    });
+};

package/package.json

@@ -1,33 +1,44 @@
-{
-  "name": "@leofcoin/endpoints",
-  "version": "0.3.1",
-  "description": "",
-  "type": "module",
-  "exports": {
-    "./api": "./exports/api.md",
-    "./http": "./exports/http.js",
-    "./ws": "./exports/ws.js"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/leofcoin/endpoints.git"
-  },
-  "bugs": {
-    "url": "https://github.com/leofcoin/endpoints/issues"
-  },
-  "homepage": "https://github.com/leofcoin/endpoints#readme",
-  "dependencies": {
-    "@koa/cors": "^4.0.0",
-    "@koa/router": "^12.0.0",
-    "@leofcoin/utils": "^1.1.5",
-    "koa": "^2.14.1",
-    "showdown": "^2.1.0",
-    "socket-request-server": "^1.6.3"
-  }
-}
+{
+  "name": "@leofcoin/endpoints",
+  "version": "0.3.2",
+  "description": "",
+  "type": "module",
+  "exports": {
+    "./api": "./exports/api.md",
+    "./http": "./exports/http.js",
+    "./ws": "./exports/ws.js"
+  },
+  "files": [
+    "./exports"
+  ],
+  "scripts": {
+    "build": "npx tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leofcoin/endpoints.git"
+  },
+  "bugs": {
+    "url": "https://github.com/leofcoin/endpoints/issues"
+  },
+  "homepage": "https://github.com/leofcoin/endpoints#readme",
+  "dependencies": {
+    "@koa/cors": "^5.0.0",
+    "@koa/router": "^12.0.0",
+    "@leofcoin/utils": "^1.1.10",
+    "koa": "^2.14.1",
+    "showdown": "^2.1.0",
+    "socket-request-server": "^1.6.3"
+  },
+  "devDependencies": {
+    "@types/koa__cors": "^4.0.1",
+    "@types/koa__router": "^12.0.1",
+    "@types/node": "^20.8.6",
+    "@types/showdown": "^2.0.2",
+    "typescript": "^5.2.2"
+  }
+}

package/.gitattributes

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

package/exports/api.md

@@ -1,251 +0,0 @@
-#### [selectAccount(address: `string`)](https://remote.leofcoin.org/select-account?address=)
-`address`: desired address
-> set default account to given address
-```js
-await client.selectAccount(address)
-```
-<br>
-
-#### [getBlock(index: `number`)](https://remote.leofcoin.org/getblock?index=0)
-`index`: index of the block to fetch<br>
-```js
-await client.getBlock(10)
-```
-<br>
-
-#### [blocks(amount)](https://remote.leofcoin.org/blocks)
-`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`)](https://remote.leofcoin.org/lookup?name=ArtOnlineContractFactory)
-`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()](https://remote.leofcoin.org/accounts)
-```js
-await client.accounts()
-```
-<br>
-
-#### [hasTransactionToHandle()](https://remote.leofcoin.org/hasTransactionToHandle)
-```js
-await client.hasTransactionToHandle()
-```
-<br>
-
-#### [balances()](https://remote.leofcoin.org/balances)
-> returns all balances
-```js
-await client.balances()
-```
-<br>
-
-#### [balancOf(address: `string`, format: `boolean`)](https://remote.leofcoin.org/balanceOf?address=YTqxKshWH4Qo7KprGYxQVCNYutedaE6YGoUdUPnUdFUVBPrTzgsrP&format=true)
-`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>
-
-#### [getNonce(address: `string`)](https://remote.leofcoin.org/getNonce?address=YTqxKshWH4Qo7KprGYxQVCNYutedaE6YGoUdUPnUdFUVBPrTzgsrP)
-`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.getNonce(address)
-```
-<br>
-
-#### [selectedAccount()](https://remote.leofcoin.org/selectedAccount)
-```js
-await client.selectedAccount()
-```
-<br>
-
-#### [peerId()](https://remote.leofcoin.org/peerId)
-```js
-await client.peerId()
-```
-<br>
-
-#### [peers()](https://remote.leofcoin.org/peers)
-```js
-await client.peers()
-```
-<br>
-
-#### [validators()](https://remote.leofcoin.org/validators)
-```js
-await client.validators()
-```
-<br>
-
-#### [nativeBurns()](https://remote.leofcoin.org/nativeBurns)
-```js
-await client.nativeBurns()
-```
-<br>
-
-#### [contracts()](https://remote.leofcoin.org/contracts)
-```js
-await client.contracts()
-```
-<br>
-
-#### [nativeMints()](https://remote.leofcoin.org/nativeMints)
-```js
-await client.nativeMints()
-```
-<br>
-
-#### [nativeToken()](https://remote.leofcoin.org/nativeToken)
-```js
-await client.nativeToken()
-```
-<br>
-
-#### [nativeTransfers()](https://remote.leofcoin.org/nativeTransfers)
-```js
-await client.  nativeTransfers()
-```
-<br>
-
-#### [totalSize()](https://remote.leofcoin.org/totalSize)
-```js
-await client.totalSize()
-```
-<br>
-
-#### [totalTransactions()](https://remote.leofcoin.org/totalTransactions)
-```js
-await client.totalTransactions()
-```
-<br>
-
-#### [poolTransactions()](https://remote.leofcoin.org/poolTransactions)
-```js
-await client.poolTransactions()
-```
-<br>
-
-#### [transactionsInPool()](https://remote.leofcoin.org/transactionsInPool)
-```js
-await client.transactionsInPool()
-```
-<br>
-
-#### [transactionPoolSize()](https://remote.leofcoin.org/transactionPoolSize)
-```js
-await client.transactionPoolSize()
-```
-<br>
-
-#### [totalBlocks()](https://remote.leofcoin.org/totalBlocks)
-```js
-await client.totalBlocks()
-```
-<br>
-
-#### [nativeCalls()](https://remote.leofcoin.org/nativeCalls)
-```js
-await client.nativeCalls()
-```
-<br>
-
-#### [participating()](https://remote.leofcoin.org/participating)
-```js
-await client.participating()
-```
-<br>
-
-#### [network()](https://remote.leofcoin.org/network)
-```js
-await client.network()
-```
-<br>
-
-#### [networkStats()](https://remote.leofcoin.org/networkStats)
-```js
-await client.networkStats()
-```
-<br>
-
-#### [networkStats()](https://remote.leofcoin.org/networkStats)
-```js
-await client.networkStats()
-```
-<br>
-
-#### [lastBlock()](https://remote.leofcoin.org/lastBlock)
-```js
-await client.lastBlock()
-```
-<br>
-
-#### [blockHashMap()](https://remote.leofcoin.org/blockHashMap)
-```js
-await client.blockHashMap()
-```
-<br>
-
-#### [bootstrap()](https://remote.leofcoin.org/bootstrap)
-```js
-await client.bootstrap()
-```
-<br>