@leofcoin/peernet 0.9.4 → 0.9.7

package/src/handlers/message.js

@@ -0,0 +1,52 @@
+import MultiWallet from '@leofcoin/multi-wallet'
+import Hash from './../hash/hash.js'
+import PeernetMessage from './../messages/peernet-message.js'
+
+export default class MessageHandler {
+  constructor(network) {
+    this.network = network
+  }
+  /**
+   * hash and sign message
+   *
+   * @param {object} message
+   * @param {Buffer} message.from peer id
+   * @param {Buffer} message.to peer id
+   * @param {string} message.data Peernet message
+   * (PeernetMessage excluded) encoded as a string
+   * @return signature
+   */
+  async hashAndSignMessage(message) {
+    const hasher = new Hash(message, {name: 'peernet-message'})
+    const identity = await walletStore.get('identity')
+
+    const wallet = new MultiWallet(this.network)
+    wallet.import(identity.multiWIF)
+    return wallet.sign(hasher.hash.slice(0, 32))
+  }
+
+  /**
+   * @param {String} from - peer id
+   * @param {String} to - peer id
+   * @param {String|PeernetMessage} data - data encoded message string
+   * or the messageNode itself
+   */
+  async prepareMessage(from, to, data) {
+    if (!Buffer.isBuffer(from)) from = new Buffer.from(from)
+    if (!Buffer.isBuffer(to)) to = new Buffer.from(to)
+    if (data.encoded) data = data.encoded
+
+    const message = {
+      from,
+      to,
+      data,
+    }
+    const signature = await this.hashAndSignMessage(message)
+    const node = new PeernetMessage({
+      ...message,
+      signature,
+    })
+
+    return node
+  }
+}

package/src/hash/hash.js

@@ -0,0 +1,145 @@
+import createKeccakHash from 'keccak';
+import varint from 'varint';
+import bs32 from 'bs32';
+import bs58 from 'bs58';
+import isHex from 'is-hex';
+import Codec from './../codec/codec';
+
+export default class PeernetHash {
+  constructor(buffer, options = {}) {
+    if (options.name) this.name = options.name
+    else this.name = 'disco-hash'
+    if (options.codecs) this.codecs = options.codecs
+    if (buffer) {
+      if (Buffer.isBuffer(buffer)) {
+        this.discoCodec = new Codec(buffer, this.codecs)
+        const name = this.discoCodec.name
+
+        if (name) {
+          this.name = name
+          this.decode(buffer)
+        } else {
+          this.encode(buffer)
+        }
+      }
+
+      if (typeof buffer === 'string') {
+        if (isHex(buffer)) this.fromHex(buffer)
+        if (bs32.test(buffer)) this.fromBs32(buffer)
+        else this.fromBs58(buffer)
+      } else if (typeof buffer === 'object') this.fromJSON(buffer)
+    }
+  }
+
+  get prefix() {
+    return Buffer.concat([this.discoCodec.codecBuffer, this.length])
+  }
+
+  get length() {
+    return Buffer.from(varint.encode(this.size))
+  }
+
+  get buffer() {
+    return this.hash
+  }
+
+  toHex() {
+    return this.hash.toString('hex')
+  }
+
+  fromHex(hex) {
+    return this.decode(Buffer.from(hex, 'hex'))
+  }
+
+  fromJSON(json) {
+    return this.encode(Buffer.from(JSON.stringify(json)))
+  }
+
+  toBs32() {
+    return bs32.encode(this.hash)
+  }
+
+  fromBs32(bs) {
+    return this.decode(bs32.decode(bs))
+  }
+
+  toBs58() {
+    return bs58.encode(this.hash)
+  }
+
+  fromBs58(bs) {
+    return this.decode(bs58.decode(bs))
+  }
+
+  toString(encoding = 'utf8') {
+    return this.hash.toString(encoding)
+  }
+
+  encode(buffer, name) {
+    if (!this.name && name) this.name = name;
+    if (!buffer) buffer = this.buffer;
+    this.discoCodec = new Codec(this.name, this.codecs)
+    this.discoCodec.fromName(this.name)
+    let hashAlg = this.discoCodec.hashAlg
+    if (hashAlg.includes('dbl')) {
+      hashAlg = hashAlg.replace('dbl-', '')
+      buffer = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
+    }
+    this.digest = createKeccakHash(hashAlg.replace('-', '')).update(buffer).digest()
+    this.size = this.digest.length
+
+    this.codec = this.discoCodec.encode();
+    this.codec = this.discoCodec.codecBuffer
+    this.hash = Buffer.concat([
+      this.prefix,
+      this.digest,
+    ])
+
+    return this.hash
+  }
+
+  validate(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+      const codec = varint.decode(buffer);
+      if (this.codecs[codec]) {
+        this.decode(buffer)
+      } else {
+        this.encode(buffer)
+      }
+    }
+    if (typeof buffer === 'string') {
+      if (isHex(buffer)) this.fromHex(buffer)
+      if (bs32.test(buffer)) this.fromBs32(buffer)
+    }
+    if (typeof buffer === 'object') this.fromJSON(buffer)
+  }
+
+  decode(buffer) {
+    this.hash = buffer
+    const codec = varint.decode(buffer);
+
+    this.discoCodec = new Codec(codec, this.codecs)
+    // TODO: validate codec
+    buffer = buffer.slice(varint.decode.bytes);
+    this.size = varint.decode(buffer);
+    this.digest = buffer.slice(varint.decode.bytes);
+    if (this.digest.length !== this.size) {
+      throw new Error(`hash length inconsistent: 0x${this.hash.toString('hex')}`)
+    }
+
+    // const discoCodec = new Codec(codec, this.codecs)
+
+    this.name = this.discoCodec.name
+
+
+    this.size = this.digest.length
+
+    return {
+      codec: this.codec,
+      name: this.name,
+      size: this.size,
+      length: this.length,
+      digest: this.digest,
+    }
+  }
+}

package/src/http/api.js

@@ -0,0 +1,115 @@
+import {version} from './../../package.json'
+
+export default {
+  version: ({send}) => send({client: '@peernet/api/http', version}),
+  ready: ({send}) => {
+    if (globalThis.states.ready) send(true)
+    else pubsub.subscribe('ready', () => send(true))
+  },
+  storage: async (params, {send, error}) => {
+    console.log(params);
+    const {name, root, key, value, method} = params
+    try {
+      if (name && root) {
+        globalThis[name] = globalThis[name] || await new LeofcoinStorage(name, root)
+      } else {
+        return error('Expected name & root')
+      }
+      if (method === 'put') {
+        await globalThis[name].put(key, value)
+        return send('ok')
+      }
+      if (method === 'remove') {
+        await globalThis[name].remove(key, value)
+        return send('ok')
+      }
+      value = await globalThis[name].get(key)
+      return send(value)
+    } catch (e) {
+      return error(e)
+    }
+  },
+  getConfig: async (params, {send, error}) => {
+    try {
+      const config = await api.getConfig(params)
+      send(config)
+    } catch (e) {
+      error(e)
+    }
+  },
+  setMinerConfig: async (params, {send, error}) => {
+    try {
+      await api.setMinerConfig(params)
+      send('ok')
+    } catch (e) {
+      error(e)
+    }
+  },
+  getMinerConfig: async ({send, error}) => {
+    try {
+      const config = await api.getMinerConfig()
+      send(config)
+    } catch (e) {
+      error(e)
+    }
+  },
+  wallet: async ({send}) => {
+    const wallet = await walletStore.get()
+    send(wallet)
+  },
+  addresses: async ({send, error}) => {
+    try {
+      const adresses = await api.addresses()
+      send(adresses)
+    } catch (e) {
+      error(e)
+    }
+  },
+  accountNames: async (params, {send, error}) => {
+    try {
+      const adresses = await api.accountNames(params.index)
+      send(adresses)
+    } catch (e) {
+      error(e)
+    }
+  },
+  accounts: async ({send}) => {
+    const accounts = await accountStore.get()
+    send(accounts)
+  },
+  account: async (params, {send}) => {
+    const account = await accountStore.get(params)
+    send(account)
+  },
+  balance: async (params, {send, error}) => {
+    console.log('balance');
+    try {
+      console.log(await api.getBalanceForAddress(params.address));
+      const value = await api.getBalanceForAddress(params.address)
+      send(value)
+    } catch (e) {
+      console.log(e);
+      error(e)
+    }
+  },
+  balanceAfter: async (params, {send, error}) => {
+    try {
+      const value = await api.getBalanceForAddressAfter(params.address, params.index)
+      send(value)
+    } catch (e) {
+      error(e)
+    }
+  },
+  mine: async (params, {send, error}) => {
+    api.mine(params)
+    send('ok')
+  },
+  lastBlock: async ({send, error}) => {
+    try {
+      const value = await api.lastBlock()
+      send(value)
+    } catch (e) {
+      error(e)
+    }
+  },
+}

package/src/http/client/api.js

@@ -0,0 +1,41 @@
+import HttpClientApi from './http-client.js'
+
+export default class extends HttpClientApi {
+  constructor(config = {}) {
+    config.apiPath = 'api';
+    return (async () => {
+      await super(config)
+
+      this.properties = {
+        wallet: 'get',
+        version: 'get',
+        addresses: 'get',
+        config: 'get',
+        account: 'get',
+        accounts: 'get',
+        transaction: 'any',
+        transactions: 'get',
+        block: 'get',
+        blocks: 'get',
+      }
+      this.keys = Object.keys(this.properties)
+      return this
+    })()
+  }
+
+  async request(url, data) {
+    return await this.client.request({url, params: data})
+  }
+
+  async ready() {
+    return await this.request('ready')
+  }
+
+  async version() {
+    return await this.request('version')
+  }
+
+  async account(index) {
+    return await this.request('account', {index})
+  }
+}

package/src/http/client/client.js

@@ -0,0 +1,10 @@
+import HttpClientApi from './api.js'
+
+export default (config = {}) => {
+  if (typeof config !== 'object') config = {}
+  if (!config.protocol) config.protocol = 'peernet-v0.1.0'
+  if (!config.port) config.port = 1000
+  if (!config.host) config.host = '127.0.0.1'
+
+  return new HttpClientApi(config)
+}

package/src/http/client/http-client.js

@@ -0,0 +1,44 @@
+import Client from './../../../node_modules/socket-request-client/src/index.js'
+
+export default class HttpClientApi {
+  constructor(config = {}) {
+    if (!config.apiPath) config.apiPath = 'api'
+
+    const address = `ws://${config.host}:${config.port}`
+
+    this.apiUrl = (url) => `${address}/${url}`;
+    return (async () => {
+      this.client = await Client(address, config.protocol, {pubsub: config.pubsub, retry: 3000})
+      return this
+    })()
+  }
+
+  async get(url, obj) {
+    const headers = {}
+    let body = null
+    let method = 'GET'
+    if (obj) {
+      method = 'POST'
+      headers['Content-Type'] = 'application/json'
+      body = JSON.stringify(obj)
+    }
+    let response = await this.client.request(url, {headers, body, method})
+    const type = response.headers.get('content-type').split(';')[0]
+    if (type==='application/json') response = await response.json()
+    return response
+  }
+
+  async put(url, obj) {
+    const headers = {}
+    let body = {}
+    if (obj) {
+      headers['Content-Type'] = 'application/json'
+      body = JSON.stringify(obj)
+    }
+
+    let response = await fetch(this.apiUrl(url), {method: 'PUT', headers, body})
+    const type = response.headers.get('content-type').split(';')[0]
+    if (type==='application/json') response = await response.json()
+    return response
+  }
+}

package/src/http/client/storage.js

@@ -0,0 +1,36 @@
+export default class LeofcoinStorageClient {
+  constructor(name, root) {
+    this.name = name
+    this.root = root
+  }
+
+  async get(key) {
+    try {
+      const result = await globalThis.peernet.client.request('storage', {
+        name: this.name,
+        root: this.root,
+        key,
+      })
+      return result
+    } catch (e) {
+      console.log(e);
+      return undefined
+    }
+  }
+
+  async put(key, value) {
+    try {
+      const result = await globalThis.peernet.client.request('storage', {
+        name: this.name,
+        root: this.root,
+        key,
+        value,
+        method: 'put',
+      })
+      return result
+    } catch (e) {
+      console.log(e);
+      return undefined
+    }
+  }
+}

package/src/http/http.js

@@ -0,0 +1,28 @@
+import api from './api.js'
+import server from './../../node_modules/socket-request-server/src/index'
+import {createServer} from 'http'
+import Koa from 'koa'
+import {version} from './../../package.json'
+export default (config = {}) => {
+  if (typeof config !== 'object') config = {}
+  if (!config.protocol) config.protocol = 'peernet-v0.1.0'
+  if (!config.port) config.port = 2000
+  if (!config.host) config.host = '127.0.0.1'
+
+  const app = new Koa()
+
+  app.use(async (ctx) => {
+    const url = ctx.url.split('/api/')[1]
+    if (url === 'version') ctx.body = {client: '@peernet/api/http', version}
+  })
+
+  const httpServer = createServer(app.callback())
+
+  config.httpServer = httpServer
+
+  httpServer.listen(config.port, () => {
+    console.log(`listening on ${config.port}`);
+  });
+
+  return server(config, api)
+}

package/src/messages/chat-message.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/chat-message.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class ChatMessage extends CodecFormat {
+  get keys() {
+    return ['author', 'value', 'timestamp', 'files']
+  }
+
+  constructor(buffer) {
+    const name = 'chat-message'
+    super(buffer, protons(proto).ChatMessage, {name})
+  }
+}

package/src/messages/data-response.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/data-response.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class DataMessageResponse extends CodecFormat {
+  get keys() {
+    return ['hash', 'data']
+  }
+
+  constructor(data) {
+    const name = 'peernet-data-response'
+    super(data, protons(proto).PeernetDataMessageResponse, {name})
+  }
+}

package/src/messages/data.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/data.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class DataMessage extends CodecFormat {
+  get keys() {
+    return ['hash', 'store']
+  }
+
+  constructor(data) {
+    const name = 'peernet-data'
+    super(data, protons(proto).PeernetDataMessage, {name})
+  }
+}

package/src/messages/dht-response.js

@@ -0,0 +1,15 @@
+import protons from 'protons'
+import proto from './../proto/dht-response.proto.js'
+import {encode, decode} from 'bs32'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class DHTMessageResponse extends CodecFormat {
+  get keys() {
+    return ['hash', 'has']
+  }
+
+  constructor(data) {
+    const name = 'peernet-dht-response'
+    super(data, protons(proto).PeernetDHTMessageResponse, {name})
+  }
+}

package/src/messages/dht.js

@@ -0,0 +1,25 @@
+import protons from 'protons'
+import proto from './../proto/dht.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+/**
+ * @example `
+   new DHTMessage(hash, store)
+   // store = optional if not set, peernet checks every store
+   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
+   message = new DHTMessage('hashmvbs124xcfd...', 'block')
+ `
+ */
+export default class DHTMessage extends CodecFormat {
+  /**
+   *
+   */
+  get keys() {
+    return ['hash', 'store']
+  }
+
+  constructor(data) {
+    const name = 'peernet-dht'
+    super(data, protons(proto).PeernetDHTMessage, {name})
+  }
+}

package/src/messages/peer-response.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/peer-response.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class PeerMessageResponse extends CodecFormat {
+  get keys() {
+    return ['id']
+  }
+
+  constructor(data) {
+    const name = 'peernet-peer-response'
+    super(data, protons(proto).PeernetPeerMessageResponse, {name})
+  }
+}

package/src/messages/peer.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/peer.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class PeerMessage extends CodecFormat {
+  get keys() {
+    return ['id']
+  }
+
+  constructor(data) {
+    const name = 'peernet-peer'
+    super(data, protons(proto).PeernetPeerMessage, {name})
+  }
+}

package/src/messages/peernet-message.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/peernet.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class PeernetMessage extends CodecFormat {
+  get keys() {
+    return ['data', 'signature', 'from', 'to', 'id']
+  }
+
+  constructor(buffer) {
+    const name = 'peernet-message'
+    super(buffer, protons(proto).PeernetMessage, {name})
+  }
+}

package/src/messages/ps.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/ps.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class PsMessage extends CodecFormat {
+  get keys() {
+    return ['data', 'topic']
+  }
+
+  constructor(buffer) {
+    const name = 'peernet-ps'
+    super(buffer, protons(proto).PsMessage, {name})
+  }
+}

package/src/messages/request.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/request.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class RequestMessage extends CodecFormat {
+  get keys() {
+    return ['request']
+  }
+
+  constructor(data) {
+    const name = 'peernet-request'
+    super(data, protons(proto).PeernetRequestMessage, {name})
+  }
+}

package/src/messages/response.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../proto/response.proto.js'
+import CodecFormat from './../codec/codec-format-interface.js'
+
+export default class ResponseMessage extends CodecFormat {
+  get keys() {
+    return ['response']
+  }
+
+  constructor(data) {
+    const name = 'peernet-response'
+    super(data, protons(proto).PeernetResponseMessage, {name})
+  }
+}

package/src/peer-info.js

@@ -0,0 +1,9 @@
+import CodecFormat from './codec/codec-format-interface'
+
+export default class PeerInfo extends CodecFormat {
+  constructor(data, options) {
+    super(data, options)
+
+    this.keys = ['id', 'address', 'family']
+  }
+}