ara-identity/protobuf/messages.js

Create and resolve decentralized identity based Ara identifiers.

// This file is auto generated by the protocol-buffers cli tool

/* eslint-disable quotes */
/* eslint-disable indent */
/* eslint-disable no-redeclare */
/* eslint-disable camelcase */

// Remember to `npm install --save protocol-buffers-encodings`
var encodings = require('protocol-buffers-encodings')
var varint = encodings.varint
var skip = encodings.skip

var KeyStore = exports.KeyStore = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Identity = exports.Identity = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Archive = exports.Archive = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Keys = exports.Keys = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var KeyPair = exports.KeyPair = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

defineKeyStore()
defineIdentity()
defineArchive()
defineKeys()
defineKeyPair()

function defineKeyStore () {
  var Crypto = KeyStore.Crypto = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  defineCrypto()

  function defineCrypto () {
    var CipherParams = Crypto.CipherParams = {
      buffer: true,
      encodingLength: null,
      encode: null,
      decode: null
    }

    var KDFParams = Crypto.KDFParams = {
      buffer: true,
      encodingLength: null,
      encode: null,
      decode: null
    }

    defineCipherParams()
    defineKDFParams()

    function defineCipherParams () {
      var enc = [
        encodings.string
      ]

      CipherParams.encodingLength = encodingLength
      CipherParams.encode = encode
      CipherParams.decode = decode

      function encodingLength (obj) {
        var length = 0
        if (defined(obj.iv)) {
          var len = enc[0].encodingLength(obj.iv)
          length += 1 + len
        }
        return length
      }

      function encode (obj, buf, offset) {
        if (!offset) offset = 0
        if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
        var oldOffset = offset
        if (defined(obj.iv)) {
          buf[offset++] = 10
          enc[0].encode(obj.iv, buf, offset)
          offset += enc[0].encode.bytes
        }
        encode.bytes = offset - oldOffset
        return buf
      }

      function decode (buf, offset, end) {
        if (!offset) offset = 0
        if (!end) end = buf.length
        if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
        var oldOffset = offset
        var obj = {
          iv: ""
        }
        while (true) {
          if (end <= offset) {
            decode.bytes = offset - oldOffset
            return obj
          }
          var prefix = varint.decode(buf, offset)
          offset += varint.decode.bytes
          var tag = prefix >> 3
          switch (tag) {
            case 1:
            obj.iv = enc[0].decode(buf, offset)
            offset += enc[0].decode.bytes
            break
            default:
            offset = skip(prefix & 7, buf, offset)
          }
        }
      }
    }

    function defineKDFParams () {
      var enc = [
        encodings.varint,
        encodings.string
      ]

      KDFParams.encodingLength = encodingLength
      KDFParams.encode = encode
      KDFParams.decode = decode

      function encodingLength (obj) {
        var length = 0
        if (defined(obj.dklen)) {
          var len = enc[0].encodingLength(obj.dklen)
          length += 1 + len
        }
        if (defined(obj.n)) {
          var len = enc[0].encodingLength(obj.n)
          length += 1 + len
        }
        if (defined(obj.r)) {
          var len = enc[0].encodingLength(obj.r)
          length += 1 + len
        }
        if (defined(obj.p)) {
          var len = enc[0].encodingLength(obj.p)
          length += 1 + len
        }
        if (defined(obj.c)) {
          var len = enc[0].encodingLength(obj.c)
          length += 1 + len
        }
        if (defined(obj.prf)) {
          var len = enc[1].encodingLength(obj.prf)
          length += 1 + len
        }
        if (defined(obj.salt)) {
          var len = enc[1].encodingLength(obj.salt)
          length += 1 + len
        }
        return length
      }

      function encode (obj, buf, offset) {
        if (!offset) offset = 0
        if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
        var oldOffset = offset
        if (defined(obj.dklen)) {
          buf[offset++] = 8
          enc[0].encode(obj.dklen, buf, offset)
          offset += enc[0].encode.bytes
        }
        if (defined(obj.n)) {
          buf[offset++] = 16
          enc[0].encode(obj.n, buf, offset)
          offset += enc[0].encode.bytes
        }
        if (defined(obj.r)) {
          buf[offset++] = 24
          enc[0].encode(obj.r, buf, offset)
          offset += enc[0].encode.bytes
        }
        if (defined(obj.p)) {
          buf[offset++] = 32
          enc[0].encode(obj.p, buf, offset)
          offset += enc[0].encode.bytes
        }
        if (defined(obj.c)) {
          buf[offset++] = 40
          enc[0].encode(obj.c, buf, offset)
          offset += enc[0].encode.bytes
        }
        if (defined(obj.prf)) {
          buf[offset++] = 50
          enc[1].encode(obj.prf, buf, offset)
          offset += enc[1].encode.bytes
        }
        if (defined(obj.salt)) {
          buf[offset++] = 58
          enc[1].encode(obj.salt, buf, offset)
          offset += enc[1].encode.bytes
        }
        encode.bytes = offset - oldOffset
        return buf
      }

      function decode (buf, offset, end) {
        if (!offset) offset = 0
        if (!end) end = buf.length
        if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
        var oldOffset = offset
        var obj = {
          dklen: 0,
          n: 0,
          r: 0,
          p: 0,
          c: 0,
          prf: "",
          salt: ""
        }
        while (true) {
          if (end <= offset) {
            decode.bytes = offset - oldOffset
            return obj
          }
          var prefix = varint.decode(buf, offset)
          offset += varint.decode.bytes
          var tag = prefix >> 3
          switch (tag) {
            case 1:
            obj.dklen = enc[0].decode(buf, offset)
            offset += enc[0].decode.bytes
            break
            case 2:
            obj.n = enc[0].decode(buf, offset)
            offset += enc[0].decode.bytes
            break
            case 3:
            obj.r = enc[0].decode(buf, offset)
            offset += enc[0].decode.bytes
            break
            case 4:
            obj.p = enc[0].decode(buf, offset)
            offset += enc[0].decode.bytes
            break
            case 5:
            obj.c = enc[0].decode(buf, offset)
            offset += enc[0].decode.bytes
            break
            case 6:
            obj.prf = enc[1].decode(buf, offset)
            offset += enc[1].decode.bytes
            break
            case 7:
            obj.salt = enc[1].decode(buf, offset)
            offset += enc[1].decode.bytes
            break
            default:
            offset = skip(prefix & 7, buf, offset)
          }
        }
      }
    }

    var enc = [
      encodings.string,
      CipherParams,
      KDFParams
    ]

    Crypto.encodingLength = encodingLength
    Crypto.encode = encode
    Crypto.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (defined(obj.cipher)) {
        var len = enc[0].encodingLength(obj.cipher)
        length += 1 + len
      }
      if (defined(obj.ciphertext)) {
        var len = enc[0].encodingLength(obj.ciphertext)
        length += 1 + len
      }
      if (defined(obj.cipherparams)) {
        var len = enc[1].encodingLength(obj.cipherparams)
        length += varint.encodingLength(len)
        length += 1 + len
      }
      if (defined(obj.mac)) {
        var len = enc[0].encodingLength(obj.mac)
        length += 1 + len
      }
      if (defined(obj.kdf)) {
        var len = enc[0].encodingLength(obj.kdf)
        length += 1 + len
      }
      if (defined(obj.kdfparams)) {
        var len = enc[2].encodingLength(obj.kdfparams)
        length += varint.encodingLength(len)
        length += 1 + len
      }
      if (defined(obj.digest)) {
        var len = enc[0].encodingLength(obj.digest)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (defined(obj.cipher)) {
        buf[offset++] = 10
        enc[0].encode(obj.cipher, buf, offset)
        offset += enc[0].encode.bytes
      }
      if (defined(obj.ciphertext)) {
        buf[offset++] = 18
        enc[0].encode(obj.ciphertext, buf, offset)
        offset += enc[0].encode.bytes
      }
      if (defined(obj.cipherparams)) {
        buf[offset++] = 26
        varint.encode(enc[1].encodingLength(obj.cipherparams), buf, offset)
        offset += varint.encode.bytes
        enc[1].encode(obj.cipherparams, buf, offset)
        offset += enc[1].encode.bytes
      }
      if (defined(obj.mac)) {
        buf[offset++] = 34
        enc[0].encode(obj.mac, buf, offset)
        offset += enc[0].encode.bytes
      }
      if (defined(obj.kdf)) {
        buf[offset++] = 42
        enc[0].encode(obj.kdf, buf, offset)
        offset += enc[0].encode.bytes
      }
      if (defined(obj.kdfparams)) {
        buf[offset++] = 50
        varint.encode(enc[2].encodingLength(obj.kdfparams), buf, offset)
        offset += varint.encode.bytes
        enc[2].encode(obj.kdfparams, buf, offset)
        offset += enc[2].encode.bytes
      }
      if (defined(obj.digest)) {
        buf[offset++] = 58
        enc[0].encode(obj.digest, buf, offset)
        offset += enc[0].encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        cipher: "",
        ciphertext: "",
        cipherparams: null,
        mac: "",
        kdf: "",
        kdfparams: null,
        digest: ""
      }
      while (true) {
        if (end <= offset) {
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 1:
          obj.cipher = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          case 2:
          obj.ciphertext = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          case 3:
          var len = varint.decode(buf, offset)
          offset += varint.decode.bytes
          obj.cipherparams = enc[1].decode(buf, offset, offset + len)
          offset += enc[1].decode.bytes
          break
          case 4:
          obj.mac = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          case 5:
          obj.kdf = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          case 6:
          var len = varint.decode(buf, offset)
          offset += varint.decode.bytes
          obj.kdfparams = enc[2].decode(buf, offset, offset + len)
          offset += enc[2].decode.bytes
          break
          case 7:
          obj.digest = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  var enc = [
    encodings.varint,
    encodings.string,
    Crypto
  ]

  KeyStore.encodingLength = encodingLength
  KeyStore.encode = encode
  KeyStore.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.version)) {
      var len = enc[0].encodingLength(obj.version)
      length += 1 + len
    }
    if (defined(obj.address)) {
      var len = enc[1].encodingLength(obj.address)
      length += 1 + len
    }
    if (defined(obj.id)) {
      var len = enc[1].encodingLength(obj.id)
      length += 1 + len
    }
    if (defined(obj.crypto)) {
      var len = enc[2].encodingLength(obj.crypto)
      length += varint.encodingLength(len)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (defined(obj.version)) {
      buf[offset++] = 8
      enc[0].encode(obj.version, buf, offset)
      offset += enc[0].encode.bytes
    }
    if (defined(obj.address)) {
      buf[offset++] = 18
      enc[1].encode(obj.address, buf, offset)
      offset += enc[1].encode.bytes
    }
    if (defined(obj.id)) {
      buf[offset++] = 26
      enc[1].encode(obj.id, buf, offset)
      offset += enc[1].encode.bytes
    }
    if (defined(obj.crypto)) {
      buf[offset++] = 34
      varint.encode(enc[2].encodingLength(obj.crypto), buf, offset)
      offset += varint.encode.bytes
      enc[2].encode(obj.crypto, buf, offset)
      offset += enc[2].encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      version: 0,
      address: "",
      id: "",
      crypto: null
    }
    while (true) {
      if (end <= offset) {
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.version = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        case 2:
        obj.address = enc[1].decode(buf, offset)
        offset += enc[1].decode.bytes
        break
        case 3:
        obj.id = enc[1].decode(buf, offset)
        offset += enc[1].decode.bytes
        break
        case 4:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.crypto = enc[2].decode(buf, offset, offset + len)
        offset += enc[2].decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIdentity () {
  var Proof = Identity.Proof = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  var File = Identity.File = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  defineProof()
  defineFile()

  function defineProof () {
    var enc = [
      encodings.bytes
    ]

    Proof.encodingLength = encodingLength
    Proof.encode = encode
    Proof.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (defined(obj.signature)) {
        var len = enc[0].encodingLength(obj.signature)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (defined(obj.signature)) {
        buf[offset++] = 10
        enc[0].encode(obj.signature, buf, offset)
        offset += enc[0].encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        signature: null
      }
      while (true) {
        if (end <= offset) {
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 1:
          obj.signature = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  function defineFile () {
    var enc = [
      encodings.string,
      encodings.bytes
    ]

    File.encodingLength = encodingLength
    File.encode = encode
    File.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (defined(obj.path)) {
        var len = enc[0].encodingLength(obj.path)
        length += 1 + len
      }
      if (defined(obj.buffer)) {
        var len = enc[1].encodingLength(obj.buffer)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (defined(obj.path)) {
        buf[offset++] = 10
        enc[0].encode(obj.path, buf, offset)
        offset += enc[0].encode.bytes
      }
      if (defined(obj.buffer)) {
        buf[offset++] = 18
        enc[1].encode(obj.buffer, buf, offset)
        offset += enc[1].encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        path: "",
        buffer: null
      }
      while (true) {
        if (end <= offset) {
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 1:
          obj.path = enc[0].decode(buf, offset)
          offset += enc[0].decode.bytes
          break
          case 2:
          obj.buffer = enc[1].decode(buf, offset)
          offset += enc[1].decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  var enc = [
    encodings.string,
    encodings.bytes,
    Proof,
    File
  ]

  Identity.encodingLength = encodingLength
  Identity.encode = encode
  Identity.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.did)) {
      var len = enc[0].encodingLength(obj.did)
      length += 1 + len
    }
    if (defined(obj.key)) {
      var len = enc[1].encodingLength(obj.key)
      length += 1 + len
    }
    if (defined(obj.proof)) {
      var len = enc[2].encodingLength(obj.proof)
      length += varint.encodingLength(len)
      length += 1 + len
    }
    if (defined(obj.files)) {
      for (var i = 0; i < obj.files.length; i++) {
        if (!defined(obj.files[i])) continue
        var len = enc[3].encodingLength(obj.files[i])
        length += varint.encodingLength(len)
        length += 1 + len
      }
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (defined(obj.did)) {
      buf[offset++] = 10
      enc[0].encode(obj.did, buf, offset)
      offset += enc[0].encode.bytes
    }
    if (defined(obj.key)) {
      buf[offset++] = 18
      enc[1].encode(obj.key, buf, offset)
      offset += enc[1].encode.bytes
    }
    if (defined(obj.proof)) {
      buf[offset++] = 26
      varint.encode(enc[2].encodingLength(obj.proof), buf, offset)
      offset += varint.encode.bytes
      enc[2].encode(obj.proof, buf, offset)
      offset += enc[2].encode.bytes
    }
    if (defined(obj.files)) {
      for (var i = 0; i < obj.files.length; i++) {
        if (!defined(obj.files[i])) continue
        buf[offset++] = 34
        varint.encode(enc[3].encodingLength(obj.files[i]), buf, offset)
        offset += varint.encode.bytes
        enc[3].encode(obj.files[i], buf, offset)
        offset += enc[3].encode.bytes
      }
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      did: "",
      key: null,
      proof: null,
      files: []
    }
    while (true) {
      if (end <= offset) {
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.did = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        case 2:
        obj.key = enc[1].decode(buf, offset)
        offset += enc[1].decode.bytes
        break
        case 3:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.proof = enc[2].decode(buf, offset, offset + len)
        offset += enc[2].decode.bytes
        break
        case 4:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.files.push(enc[3].decode(buf, offset, offset + len))
        offset += enc[3].decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineArchive () {
  var enc = [
    encodings.bytes,
    encodings.bool
  ]

  Archive.encodingLength = encodingLength
  Archive.encode = encode
  Archive.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.key)) {
      var len = enc[0].encodingLength(obj.key)
      length += 1 + len
    }
    if (defined(obj.shallow)) {
      var len = enc[1].encodingLength(obj.shallow)
      length += 1 + len
    }
    if (defined(obj.signature)) {
      var len = enc[0].encodingLength(obj.signature)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (defined(obj.key)) {
      buf[offset++] = 10
      enc[0].encode(obj.key, buf, offset)
      offset += enc[0].encode.bytes
    }
    if (defined(obj.shallow)) {
      buf[offset++] = 16
      enc[1].encode(obj.shallow, buf, offset)
      offset += enc[1].encode.bytes
    }
    if (defined(obj.signature)) {
      buf[offset++] = 82
      enc[0].encode(obj.signature, buf, offset)
      offset += enc[0].encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      key: null,
      shallow: false,
      signature: null
    }
    while (true) {
      if (end <= offset) {
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.key = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        case 2:
        obj.shallow = enc[1].decode(buf, offset)
        offset += enc[1].decode.bytes
        break
        case 10:
        obj.signature = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineKeys () {
  var enc = [
    encodings.bytes,
    KeyPair
  ]

  Keys.encodingLength = encodingLength
  Keys.encode = encode
  Keys.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.signature)) {
      var len = enc[0].encodingLength(obj.signature)
      length += 1 + len
    }
    if (defined(obj.keys)) {
      for (var i = 0; i < obj.keys.length; i++) {
        if (!defined(obj.keys[i])) continue
        var len = enc[1].encodingLength(obj.keys[i])
        length += varint.encodingLength(len)
        length += 1 + len
      }
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (defined(obj.signature)) {
      buf[offset++] = 10
      enc[0].encode(obj.signature, buf, offset)
      offset += enc[0].encode.bytes
    }
    if (defined(obj.keys)) {
      for (var i = 0; i < obj.keys.length; i++) {
        if (!defined(obj.keys[i])) continue
        buf[offset++] = 18
        varint.encode(enc[1].encodingLength(obj.keys[i]), buf, offset)
        offset += varint.encode.bytes
        enc[1].encode(obj.keys[i], buf, offset)
        offset += enc[1].encode.bytes
      }
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      signature: null,
      keys: []
    }
    while (true) {
      if (end <= offset) {
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.signature = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        case 2:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.keys.push(enc[1].decode(buf, offset, offset + len))
        offset += enc[1].decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineKeyPair () {
  var enc = [
    encodings.bytes
  ]

  KeyPair.encodingLength = encodingLength
  KeyPair.encode = encode
  KeyPair.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.publicKey)) {
      var len = enc[0].encodingLength(obj.publicKey)
      length += 1 + len
    }
    if (defined(obj.secretKey)) {
      var len = enc[0].encodingLength(obj.secretKey)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (defined(obj.publicKey)) {
      buf[offset++] = 10
      enc[0].encode(obj.publicKey, buf, offset)
      offset += enc[0].encode.bytes
    }
    if (defined(obj.secretKey)) {
      buf[offset++] = 18
      enc[0].encode(obj.secretKey, buf, offset)
      offset += enc[0].encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      publicKey: null,
      secretKey: null
    }
    while (true) {
      if (end <= offset) {
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.publicKey = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        case 2:
        obj.secretKey = enc[0].decode(buf, offset)
        offset += enc[0].decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defined (val) {
  return val !== null && val !== undefined && (typeof val !== 'number' || !isNaN(val))
}