blind-peer 0.0.1

package/.github/workflows/test-node.yml

@@ -0,0 +1,23 @@
+name: Build Status
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  build:
+    strategy:
+      matrix:
+        node-version: [lts/*]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm install
+    - run: npm test

package/README.md

@@ -0,0 +1,17 @@
+# blind-peer
+
+Its a blind peer
+
+```
+npm install blind-peer
+```
+
+## Usage
+
+``` js
+const BlindPeer = require('blind-peer')
+```
+
+## License
+
+Apache-2.0

package/build.js

@@ -0,0 +1,102 @@
+const HyperDB = require('hyperdb/builder')
+const Hyperschema = require('hyperschema')
+
+const SCHEMA_DIR = './spec/hyperschema'
+const DB_DIR = './spec/hyperdb'
+
+const schema = Hyperschema.from(SCHEMA_DIR)
+const blind = schema.namespace('blind-peer')
+
+blind.register({
+  name: 'request-mailbox',
+  fields: [
+    {
+      name: 'autobase',
+      type: 'fixed32',
+      required: true
+    },
+    {
+      name: 'blockEncryptionKey',
+      type: 'fixed32'
+    }
+  ]
+})
+
+blind.register({
+  name: 'response-mailbox',
+  fields: [
+    {
+      name: 'autobase',
+      type: 'fixed32',
+      required: true
+    },
+    {
+      name: 'writer',
+      type: 'fixed32',
+      required: true
+    },
+    {
+      name: 'open',
+      type: 'bool'
+    }
+  ]
+})
+
+blind.register({
+  name: 'request-post',
+  fields: [
+    {
+      name: 'autobase',
+      type: 'fixed32',
+      required: true
+    },
+    {
+      name: 'message',
+      type: 'string'
+    }
+  ]
+})
+
+blind.register({
+  name: 'response-post',
+  fields: [
+    {
+      name: 'length',
+      type: 'uint',
+      required: true
+    }
+  ]
+})
+
+blind.register({
+  name: 'mailbox',
+  fields: [
+    {
+      name: 'autobase',
+      type: 'fixed32',
+      required: true
+    },
+    {
+      name: 'writer',
+      type: 'fixed32',
+      required: true
+    },
+    {
+      name: 'blockEncryptionKey',
+      type: 'fixed32'
+    }
+  ]
+})
+
+Hyperschema.toDisk(schema)
+
+const db = HyperDB.from(SCHEMA_DIR, DB_DIR)
+const blindDB = db.namespace('blind-peer')
+
+blindDB.collections.register({
+  name: 'mailbox',
+  schema: '@blind-peer/mailbox',
+  key: ['autobase']
+})
+
+HyperDB.toDisk(db)

package/client.js

@@ -0,0 +1,31 @@
+const schema = require('./spec/hyperschema')
+const c = require('compact-encoding')
+const ProtomuxRPC = require('protomux-rpc')
+
+const addMailboxEncoding = {
+  requestEncoding: schema.resolveStruct('@blind-peer/request-mailbox'),
+  responseEncoding: schema.resolveStruct('@blind-peer/response-mailbox')
+}
+
+const postEncoding = {
+  requestEncoding: schema.resolveStruct('@blind-peer/request-post'),
+  responseEncoding: schema.resolveStruct('@blind-peer/response-post')
+}
+
+module.exports = class BlindPeerClient {
+  constructor (stream) {
+    this.stream = stream
+    this.rpc = new ProtomuxRPC(stream, {
+      id: stream.remotePublicKey,
+      valueEncoding: c.none
+    })
+  }
+
+  addMailbox (data) {
+    return this.rpc.request('add-mailbox', data, addMailboxEncoding)
+  }
+
+  post ({ autobase, message }) {
+    return this.rpc.request('post', { autobase, message }, postEncoding)
+  }
+}

package/example/autobase.mjs

@@ -0,0 +1,62 @@
+import BlindPeerClient from '../client.js'
+import Autobase from 'autobase'
+import c from 'compact-encoding'
+import Corestore from 'corestore'
+import Hyperswarm from 'hyperswarm'
+import debounce from 'debounceify'
+
+const base = new Autobase(new Corestore('/tmp/my-corestore'), {
+  encryptionKey: Buffer.alloc(30).fill('secret'),
+  valueEncoding: c.json,
+  open (store) {
+    return store.get('view', { valueEncoding: c.json })
+  },
+  async apply (nodes, view, base) {
+    for (const node of nodes) {
+      if (node.value.add) await base.addWriter(Buffer.from(node.value.key, 'hex'), { indexer: false })
+      view.append(node.value)
+    }
+  }
+})
+
+await base.ready()
+console.log('Autobase:', base.key.toString('hex'))
+
+base.view.on('append', debounce(async function () {
+  base.ack() // ack for good messure
+  console.log('someone appended to the autobase!')
+  for (let i = 0; i < base.view.length; i++) {
+    console.log(i, await base.view.get(i))
+  }
+}))
+
+// TODO: record in autobase
+const publicKey = Buffer.from(process.argv[2], 'hex')
+
+const s = new Hyperswarm({ keyPair: await base.store.createKeyPair('tmp') })
+
+s.on('connection', async c => {
+  base.store.replicate(c)
+
+  if (!c.remotePublicKey.equals(publicKey)) return
+
+  const peer = new BlindPeerClient(c)
+
+  const info = await peer.addMailbox({ autobase: base.key })
+
+  if (info.open === false) {
+    await base.append({ add: true, key: info.writer.toString('hex') })
+    await base.update()
+
+    const core = base.store.get({ key: info.writer, active: false })
+    await core.setEncryptionKey(base.encryptionKey)
+    const req = { autobase: base.key, blockEncryptionKey: core.encryption.blockKey }
+    await core.close()
+
+    await peer.addMailbox(req)
+
+    console.log('opened mailbox...')
+  }
+})
+
+s.joinPeer(publicKey)

package/example/blind-peer.mjs

@@ -0,0 +1,6 @@
+import BlindPeer from '../index.js'
+
+const m = new BlindPeer('/tmp/blind-peer')
+await m.listen()
+
+console.log(m.publicKey.toString('hex'))

package/example/post.mjs

@@ -0,0 +1,21 @@
+import BlindPeerClient from '../client.js'
+import Hyperswarm from 'hyperswarm'
+
+const publicKey = Buffer.from(process.argv[2], 'hex')
+const autobase = Buffer.from(process.argv[3], 'hex')
+const message = process.argv[4]
+
+const s = new Hyperswarm()
+
+s.on('connection', async c => {
+  if (!c.remotePublicKey.equals(publicKey)) return
+
+  const peer = new BlindPeerClient(c)
+  const reply = await peer.post({ autobase, message })
+
+  console.log(reply)
+
+  s.destroy()
+})
+
+s.joinPeer(publicKey)

package/index.js

@@ -0,0 +1,139 @@
+const AutobaseLightWriter = require('autobase-light-writer')
+const HyperDB = require('hyperdb')
+const Corestore = require('corestore')
+const definition = require('./spec/hyperdb')
+const schema = require('./spec/hyperschema')
+const path = require('path')
+const Hyperswarm = require('hyperswarm')
+const ProtomuxRPC = require('protomux-rpc')
+const c = require('compact-encoding')
+
+module.exports = class BlindPeer {
+  constructor (storage) {
+    this.db = HyperDB.rocks(path.join(storage, 'hyperdb'), definition)
+    this.store = new Corestore(path.join(storage, 'corestore'))
+    this.store.on('core-open', this._oncoreopen.bind(this))
+    this.swarm = null
+  }
+
+  _onconnection (connection) {
+    this.store.replicate(connection)
+
+    const rpc = new ProtomuxRPC(connection, {
+      id: this.swarm.keyPair.publicKey,
+      valueEncoding: c.none
+    })
+
+    rpc.respond('add-mailbox', {
+      requestEncoding: schema.resolveStruct('@blind-peer/request-mailbox'),
+      responseEncoding: schema.resolveStruct('@blind-peer/response-mailbox')
+    }, this._onrpcadd.bind(this))
+
+    rpc.respond('post', {
+      requestEncoding: schema.resolveStruct('@blind-peer/request-post'),
+      responseEncoding: schema.resolveStruct('@blind-peer/response-post')
+    }, this._onrpcpost.bind(this))
+  }
+
+  async _onrpcadd (req) {
+    const res = await this.add(req)
+
+    return {
+      autobase: res.autobase,
+      writer: res.writer,
+      open: !!res.blockEncryptionKey // TODO: get rid of the encryption for these guys with a manifest upgrade, then no attacks cause self-described
+    }
+  }
+
+  async _onrpcpost (req) {
+    return await this.post(req)
+  }
+
+  async _oncoreopen (core) {
+    try {
+      const entry = await this.db.get('@blind-peer/mailbox', { autobase: core.key })
+      if (!entry || !entry.blockEncryptionKey) return
+
+      const w = new AutobaseLightWriter(this.store.namespace(entry.autobase), entry.autobase, {
+        active: false,
+        blockEncryptionKey: entry.blockEncryptionKey,
+        valueEncoding: c.json
+      })
+
+      for (const peer of core.peers) {
+        w.local.replicate(peer.stream)
+      }
+
+      core.on('peer-add', (peer) => {
+        w.local.replicate(peer.stream)
+      })
+
+      core.on('close', () => {
+        w.close().catch(noop)
+      })
+    } catch (err) {
+      console.log(err)
+    }
+  }
+
+  get publicKey () {
+    return this.swarm.server.publicKey
+  }
+
+  async listen ({ bootstrap } = {}) {
+    this.swarm = new Hyperswarm({
+      keyPair: await this.store.createKeyPair('blind-mailbox'),
+      bootstrap
+    })
+    this.swarm.on('connection', this._onconnection.bind(this))
+    return this.swarm.listen()
+  }
+
+  async get ({ autobase }) {
+    return await this.db.get('@blind-peer/mailbox', { autobase })
+  }
+
+  async add ({ autobase, blockEncryptionKey = null }) {
+    const prev = await this.db.get('@blind-peer/mailbox', { autobase })
+
+    if (prev) {
+      if (prev.blockEncryptionKey) return prev
+      prev.blockEncryptionKey = blockEncryptionKey
+      await this.db.insert('@blind-peer/mailbox', prev)
+      await this.db.flush()
+      return prev
+    }
+
+    const w = new AutobaseLightWriter(this.store.namespace(autobase), autobase, { active: false })
+    await w.ready()
+    const entry = { autobase, writer: w.local.key, blockEncryptionKey }
+    await this.db.insert('@blind-peer/mailbox', entry)
+    await this.db.flush()
+    await w.close()
+
+    return entry
+  }
+
+  async post ({ autobase, message }) {
+    const entry = await this.db.get('@blind-peer/mailbox', { autobase })
+    if (!entry || !entry.blockEncryptionKey) return false
+
+    const w = new AutobaseLightWriter(this.store.namespace(autobase), autobase, {
+      active: false,
+      blockEncryptionKey: entry.blockEncryptionKey,
+      valueEncoding: c.json
+    })
+    await w.append({ mailbox: true, text: message })
+    const length = w.local.length
+    await w.close()
+
+    return { length }
+  }
+
+  async close () {
+    if (this.swarm !== null) await this.swarm.destroy()
+    await this.store.close()
+  }
+}
+
+function noop () {}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "blind-peer",
+  "version": "0.0.1",
+  "description": "WIP - nothing to see here",
+  "main": "index.js",
+  "dependencies": {
+    "autobase-light-writer": "^1.1.0",
+    "corestore": "^6.18.4",
+    "hyperdb": "^4.1.2",
+    "hyperschema": "^1.0.3",
+    "hyperswarm": "^4.8.4",
+    "protomux-rpc": "^1.6.0"
+  },
+  "devDependencies": {
+    "debounceify": "^1.1.0",
+    "standard": "^17.1.2"
+  },
+  "scripts": {
+    "test": "standard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/blind-peer.git"
+  },
+  "author": "Holepunch Inc.",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/mafintosh/blind-peer/issues"
+  },
+  "homepage": "https://github.com/mafintosh/blind-peer"
+}

package/spec/hyperdb/db.json

@@ -0,0 +1,19 @@
+{
+  "version": 0,
+  "offset": 0,
+  "schema": [
+    {
+      "name": "mailbox",
+      "namespace": "blind-peer",
+      "id": 0,
+      "type": 1,
+      "indexes": [],
+      "schema": "@blind-peer/mailbox",
+      "derived": false,
+      "key": [
+        "autobase"
+      ],
+      "trigger": null
+    }
+  ]
+}

package/spec/hyperdb/index.js

@@ -0,0 +1,83 @@
+// This file is autogenerated by the hyperdb compiler
+/* eslint-disable camelcase */
+
+const { IndexEncoder, c } = require('hyperdb/runtime')
+
+const { version, resolveStruct } = require('./messages.js')
+
+// '@blind-peer/mailbox' collection key
+const collection0_key = new IndexEncoder([
+  IndexEncoder.BUFFER
+], { prefix: 0 })
+
+function collection0_indexify (record) {
+  const a = record.autobase
+  return a === undefined ? [] : [a]
+}
+
+// '@blind-peer/mailbox' reconstruction function
+function collection0_reconstruct (version, keyBuf, valueBuf) {
+  const key = collection0_key.decode(keyBuf)
+  const value = c.decode(resolveStruct('@blind-peer/mailbox/value', version), valueBuf)
+  // TODO: This should be fully code generated
+  return {
+    autobase: key[0],
+    ...value
+  }
+}
+// '@blind-peer/mailbox' key reconstruction function
+function collection0_reconstruct_key (keyBuf) {
+  const key = collection0_key.decode(keyBuf)
+  return {
+    autobase: key[0]
+  }
+}
+
+// '@blind-peer/mailbox'
+const collection0 = {
+  name: '@blind-peer/mailbox',
+  id: 0,
+  encodeKey (record) {
+    const key = [record.autobase]
+    return collection0_key.encode(key)
+  },
+  encodeKeyRange ({ gt, lt, gte, lte } = {}) {
+    return collection0_key.encodeRange({
+      gt: gt ? collection0_indexify(gt) : null,
+      lt: lt ? collection0_indexify(lt) : null,
+      gte: gte ? collection0_indexify(gte) : null,
+      lte: lte ? collection0_indexify(lte) : null
+    })
+  },
+  encodeValue (version, record) {
+    return c.encode(resolveStruct('@blind-peer/mailbox/value', version), record)
+  },
+  trigger: null,
+  reconstruct: collection0_reconstruct,
+  reconstructKey: collection0_reconstruct_key,
+  indexes: []
+}
+
+module.exports = {
+  version,
+  collections: [
+    collection0
+  ],
+  indexes: [
+  ],
+  resolveCollection,
+  resolveIndex
+}
+
+function resolveCollection (name) {
+  switch (name) {
+    case '@blind-peer/mailbox': return collection0
+    default: return null
+  }
+}
+
+function resolveIndex (name) {
+  switch (name) {
+    default: return null
+  }
+}

package/spec/hyperdb/messages.js

@@ -0,0 +1,234 @@
+// This file is autogenerated by the hyperschema compiler
+// Schema Version: 1
+/* eslint-disable camelcase */
+/* eslint-disable quotes */
+
+const VERSION = 1
+const { c } = require('hyperschema/runtime')
+
+// eslint-disable-next-line no-unused-vars
+let version = VERSION
+
+// @blind-peer/request-mailbox
+const encoding0 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.uint.preencode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.preencode(state, m.blockEncryptionKey)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.uint.encode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.encode(state, m.blockEncryptionKey)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.blockEncryptionKey = null
+
+    res.autobase = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.blockEncryptionKey = c.fixed32.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/response-mailbox
+const encoding1 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.open) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.fixed32.preencode(state, m.writer)
+    c.uint.preencode(state, flags)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.open) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.fixed32.encode(state, m.writer)
+    c.uint.encode(state, flags)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.writer = null
+    res.open = false
+
+    res.autobase = c.fixed32.decode(state)
+    res.writer = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.open = true
+
+    return res
+  }
+}
+
+// @blind-peer/request-post
+const encoding2 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.message) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.uint.preencode(state, flags)
+
+    if (m.message) c.string.preencode(state, m.message)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.message) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.uint.encode(state, flags)
+
+    if (m.message) c.string.encode(state, m.message)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.message = null
+
+    res.autobase = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.message = c.string.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/response-post
+const encoding3 = {
+  preencode (state, m) {
+    c.uint.preencode(state, m.length)
+  },
+  encode (state, m) {
+    c.uint.encode(state, m.length)
+  },
+  decode (state) {
+    const res = {}
+    res.length = 0
+
+    res.length = c.uint.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/mailbox
+const encoding4 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.fixed32.preencode(state, m.writer)
+    c.uint.preencode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.preencode(state, m.blockEncryptionKey)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.fixed32.encode(state, m.writer)
+    c.uint.encode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.encode(state, m.blockEncryptionKey)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.writer = null
+    res.blockEncryptionKey = null
+
+    res.autobase = c.fixed32.decode(state)
+    res.writer = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.blockEncryptionKey = c.fixed32.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/mailbox/value
+const encoding5 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.preencode(state, m.writer)
+    c.uint.preencode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.preencode(state, m.blockEncryptionKey)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.encode(state, m.writer)
+    c.uint.encode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.encode(state, m.blockEncryptionKey)
+  },
+  decode (state) {
+    const res = {}
+    res.writer = null
+    res.blockEncryptionKey = null
+
+    res.writer = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.blockEncryptionKey = c.fixed32.decode(state)
+
+    return res
+  }
+}
+
+function getStructByName (name) {
+  switch (name) {
+    case '@blind-peer/request-mailbox': return encoding0
+    case '@blind-peer/response-mailbox': return encoding1
+    case '@blind-peer/request-post': return encoding2
+    case '@blind-peer/response-post': return encoding3
+    case '@blind-peer/mailbox': return encoding4
+    case '@blind-peer/mailbox/value': return encoding5
+    default: throw new Error('Encoder not found ' + name)
+  }
+}
+
+function resolveStruct (name, v = VERSION) {
+  const enc = getStructByName(name)
+  return {
+    preencode (state, m) {
+      version = v
+      enc.preencode(state, m)
+    },
+    encode (state, m) {
+      version = v
+      enc.encode(state, m)
+    },
+    decode (state) {
+      version = v
+      return enc.decode(state)
+    }
+  }
+}
+
+module.exports = { resolveStruct, version }

package/spec/hyperschema/index.js

@@ -0,0 +1,199 @@
+// This file is autogenerated by the hyperschema compiler
+// Schema Version: 1
+/* eslint-disable camelcase */
+/* eslint-disable quotes */
+
+const VERSION = 1
+const { c } = require('hyperschema/runtime')
+
+// eslint-disable-next-line no-unused-vars
+let version = VERSION
+
+// @blind-peer/request-mailbox
+const encoding0 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.uint.preencode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.preencode(state, m.blockEncryptionKey)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.uint.encode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.encode(state, m.blockEncryptionKey)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.blockEncryptionKey = null
+
+    res.autobase = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.blockEncryptionKey = c.fixed32.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/response-mailbox
+const encoding1 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.open) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.fixed32.preencode(state, m.writer)
+    c.uint.preencode(state, flags)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.open) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.fixed32.encode(state, m.writer)
+    c.uint.encode(state, flags)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.writer = null
+    res.open = false
+
+    res.autobase = c.fixed32.decode(state)
+    res.writer = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.open = true
+
+    return res
+  }
+}
+
+// @blind-peer/request-post
+const encoding2 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.message) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.uint.preencode(state, flags)
+
+    if (m.message) c.string.preencode(state, m.message)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.message) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.uint.encode(state, flags)
+
+    if (m.message) c.string.encode(state, m.message)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.message = null
+
+    res.autobase = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.message = c.string.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/response-post
+const encoding3 = {
+  preencode (state, m) {
+    c.uint.preencode(state, m.length)
+  },
+  encode (state, m) {
+    c.uint.encode(state, m.length)
+  },
+  decode (state) {
+    const res = {}
+    res.length = 0
+
+    res.length = c.uint.decode(state)
+
+    return res
+  }
+}
+
+// @blind-peer/mailbox
+const encoding4 = {
+  preencode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.preencode(state, m.autobase)
+    c.fixed32.preencode(state, m.writer)
+    c.uint.preencode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.preencode(state, m.blockEncryptionKey)
+  },
+  encode (state, m) {
+    let flags = 0
+    if (m.blockEncryptionKey) flags |= 1
+
+    c.fixed32.encode(state, m.autobase)
+    c.fixed32.encode(state, m.writer)
+    c.uint.encode(state, flags)
+
+    if (m.blockEncryptionKey) c.fixed32.encode(state, m.blockEncryptionKey)
+  },
+  decode (state) {
+    const res = {}
+    res.autobase = null
+    res.writer = null
+    res.blockEncryptionKey = null
+
+    res.autobase = c.fixed32.decode(state)
+    res.writer = c.fixed32.decode(state)
+
+    const flags = state.start < state.end ? c.uint.decode(state) : 0
+    if ((flags & 1) !== 0) res.blockEncryptionKey = c.fixed32.decode(state)
+
+    return res
+  }
+}
+
+function getStructByName (name) {
+  switch (name) {
+    case '@blind-peer/request-mailbox': return encoding0
+    case '@blind-peer/response-mailbox': return encoding1
+    case '@blind-peer/request-post': return encoding2
+    case '@blind-peer/response-post': return encoding3
+    case '@blind-peer/mailbox': return encoding4
+    default: throw new Error('Encoder not found ' + name)
+  }
+}
+
+function resolveStruct (name, v = VERSION) {
+  const enc = getStructByName(name)
+  return {
+    preencode (state, m) {
+      version = v
+      enc.preencode(state, m)
+    },
+    encode (state, m) {
+      version = v
+      enc.encode(state, m)
+    },
+    decode (state) {
+      version = v
+      return enc.decode(state)
+    }
+  }
+}
+
+module.exports = { resolveStruct, version }

package/spec/hyperschema/schema.json

@@ -0,0 +1,107 @@
+{
+  "version": 1,
+  "schema": [
+    {
+      "name": "request-mailbox",
+      "namespace": "blind-peer",
+      "compact": false,
+      "flagsPosition": 1,
+      "fields": [
+        {
+          "name": "autobase",
+          "required": true,
+          "type": "fixed32",
+          "version": 1
+        },
+        {
+          "name": "blockEncryptionKey",
+          "type": "fixed32",
+          "version": 1
+        }
+      ]
+    },
+    {
+      "name": "response-mailbox",
+      "namespace": "blind-peer",
+      "compact": false,
+      "flagsPosition": 2,
+      "fields": [
+        {
+          "name": "autobase",
+          "required": true,
+          "type": "fixed32",
+          "version": 1
+        },
+        {
+          "name": "writer",
+          "required": true,
+          "type": "fixed32",
+          "version": 1
+        },
+        {
+          "name": "open",
+          "type": "bool",
+          "version": 1
+        }
+      ]
+    },
+    {
+      "name": "request-post",
+      "namespace": "blind-peer",
+      "compact": false,
+      "flagsPosition": 1,
+      "fields": [
+        {
+          "name": "autobase",
+          "required": true,
+          "type": "fixed32",
+          "version": 1
+        },
+        {
+          "name": "message",
+          "type": "string",
+          "version": 1
+        }
+      ]
+    },
+    {
+      "name": "response-post",
+      "namespace": "blind-peer",
+      "compact": false,
+      "flagsPosition": -1,
+      "fields": [
+        {
+          "name": "length",
+          "required": true,
+          "type": "uint",
+          "version": 1
+        }
+      ]
+    },
+    {
+      "name": "mailbox",
+      "namespace": "blind-peer",
+      "compact": false,
+      "flagsPosition": 2,
+      "fields": [
+        {
+          "name": "autobase",
+          "required": true,
+          "type": "fixed32",
+          "version": 1
+        },
+        {
+          "name": "writer",
+          "required": true,
+          "type": "fixed32",
+          "version": 1
+        },
+        {
+          "name": "blockEncryptionKey",
+          "type": "fixed32",
+          "version": 1
+        }
+      ]
+    }
+  ]
+}