optolink-bridge 1.0.0

package/index.js

@@ -0,0 +1,317 @@
+import async from 'async';
+import { readConfig, mapDataPoints, dateTimeString, formatAddr, directionName, fromLocalToOpto, fromOptoToLocal, toOpto, fromOpto } from './utils.js';
+import { toFormat as bufferToFormat } from 'buffer-to-str';
+import Queue from 'yocto-queue';
+
+import { connectAsync as mqttConnect } from 'mqtt';
+
+import { connect, fromOptoToVito, fromVitoToOpto } from './serial.js';
+import { default as parsePacket, parseValue, encodePacket } from './parse_vs2.js';
+import { publishDevice } from './discovery.js';
+
+let logLevel, trace, logger = {};
+let dps, pollQueue = new Queue(), pollIntervals;
+let busState = 0; // 0: syncing, 1: synced, 2: flowing
+let deviceSerialNo = undefined, deviceDiscoveryOptions = { enabled: true }, deviceDiscovery;
+
+async function applyConfig(config) {
+  logLevel = {
+    debug: 4, // debug log of all unknown data points
+    info: 3, // logs all known data points
+    warn: 2,
+    error: 1,
+    none: 0
+  }[config.log_level ?? 'warn'] || 2; // default to warn
+  trace = config.log_level === 'trace'; // trace all serial communication
+  Object.assign(logger, {
+    debug: logLevel >= 4 ? console.debug : () => {},
+    info: logLevel >= 3 ? console.log : () => {},
+    warn: logLevel >= 2 ? console.warn : () => {},
+    error: logLevel >= 1 ? console.error : () => {},
+  });
+
+  if (!dps || (config.auto_reload_addr_items ?? true)) {
+    dps ??= new Map();
+
+    // clear all existing poll intervals
+    for (const pollInterval of (pollIntervals ?? [])) {
+      clearInterval(pollInterval);
+    }
+    pollIntervals = [];
+
+    // convert the data points to a structured array
+    mapDataPoints(config.data_points, (dps.clear(), dps));
+
+    // create poll intervals for each poll item
+    let pollsPerSecond = 0.;
+    for (const [ival, addr, dlen] of (config.poll_items ?? [])) {
+      if (ival <= 0) {
+        logger.error(`Poll interval for address ${formatAddr(addr)} is less than zero, skipping poll request`);
+        continue;
+      }
+
+      const pollItem = (dupWarning = true) => {
+        // check if the address is already in the poll queue
+        for (const { addr: qaddr } of pollQueue) {
+          if (qaddr === addr) {
+            dupWarning && logger.warn(`Address ${formatAddr(addr)} is already in the poll queue, this could indicate that the poll queue is saturated, i.e. you are polling more items than Vitoconnect & the Optolink interface can handle (approx. 10 items by Vitoconnect and 10 poll items per second), or that polling has not yet started / is otherwise halted, resulting in the poll queue to overflow. Also check for duplicates in your poll_items list.`);
+            return;
+          }
+        }
+
+        pollQueue.enqueue({ addr, dlen });
+      };
+
+      pollsPerSecond += 1. / ival;
+      pollIntervals.push(setInterval(pollItem, ival * 1000));
+      pollItem(false /* do not print a warning if it is already in the queue (on reload) */); // poll the item once immediately after startup
+    }
+    pollsPerSecond > 5. && logger.warn(`You are polling more than 5 items per second, which exceeds the (theoretical) limit of the low 4,800 bps Optolink bus baud rate. Please consider reducing the number of items in your poll_items list or the polling rate of the existing items (refer to the ival comment in the config.toml file for further information) and monitor the logs for saturation warnings of the poll queue.`);
+
+    if (deviceSerialNo === undefined) {
+      deviceSerialNo = null; // means we are waiting for the serial number to be sent by Vitoconnect, but do not allow to change it anymore if config.toml changes
+
+      const device = config.mqtt?.device_discovery?.overrides?.device;
+      deviceSerialNo = device?.serial_number || device?.identifiers || deviceSerialNo;
+      Array.isArray(deviceSerialNo) && (deviceSerialNo = deviceSerialNo[0]);
+    }
+
+    deviceDiscoveryOptions = config.mqtt?.device_discovery;
+    deviceDiscovery && await deviceDiscovery(); // (re-)publish the device discovery message, to publish any changes to the data points
+  }
+
+  return config;
+}
+
+// read and apply the config and also use "applyConfig" when the config changes
+const config = await applyConfig(await readConfig(applyConfig));
+
+let mqttClient, mqttTopic, mqttAvailabilityTopic, mqttDpTopic = dp => {
+  const suffix = (dp ? (config.suffix ?? '<dpname>') : (config.unknown_dp_suffix ?? 'raw/<addr>'))
+    .replaceAll(/<(?:dp)?addr>/g, formatAddr(dp.addr))
+    .replaceAll(/<dpname>/g, dp?.name ?? 'unknown');
+  return `${mqttTopic}${mqttTopic.endsWith('/') || suffix.startsWith('/') ? '' : '/'}${suffix}`;
+};
+
+deviceDiscovery = async function(options = (deviceDiscoveryOptions ?? { enabled: true })) {
+  if (!mqttClient?.connected || !deviceSerialNo || !(options?.enabled ?? true)) {
+    return;
+  }
+
+  try {
+    await publishDevice({
+      prefix: 'homeassistant',
+      ...options, // prefix, overrides
+      mqttClient, mqttAvailabilityTopic, mqttDpTopic,
+      deviceSerialNo, dps
+    });
+
+    logger.info('Published device discovery payload via MQTT');
+  } catch (err) {
+    logger.error('Failed to publish device discovery via MQTT:', err);
+  }
+}
+
+if (config.mqtt && config.mqtt.url) {
+  config.mqtt.online ??= true; // if not set, use a online topic
+  mqttTopic = config.mqtt.topic ?? 'Vito', mqttAvailabilityTopic =
+    `${mqttTopic}${mqttTopic.endsWith('/') || config.mqtt.online.startsWith?.('/') ? '' : '/'}${
+      typeof config.mqtt.online === 'string' ? config.mqtt.online : 'online'}`;
+
+  const mqttOptions = {
+    username: config.mqtt.username,
+    password: config.mqtt.password,
+    ...(config.mqtt.options || {}),
+    ...((config.mqtt.online ?? true) ? {
+      will: { // last will to set topic offline
+        topic: mqttAvailabilityTopic,
+        payload: `${false}`,
+        retain: true
+      }
+    } : {})
+  };
+
+  // connect to MQTT broker
+  mqttClient = await mqttConnect(config.mqtt.url, mqttOptions);
+  const mqttConnected = async () => {
+    config.mqtt.online && await mqttClient.publishAsync(
+      mqttAvailabilityTopic, `${true}`, { retain: true });
+    await deviceDiscovery(); // when connected, publish the device / data points
+  };
+  await mqttConnected(); // set online topic
+  mqttClient.on('connect', mqttConnected);
+} else {
+  logger.warn('No MQTT (URL) configuration found, not publishing to MQTT');
+}
+
+// the packet queue handles all fully received packets from opto. or vito. side, as well as already parsed packets received from the polling intercept
+const polledAddr = new Set();
+const packetQueue = async.queue(async task => {
+  trace && console.log(dateTimeString(), directionName(task.direction), (task.data ?? encodePacket(task.packet, task.direction & fromOpto)).toString('hex'));
+
+  const packet = task.packet ?? parsePacket(task.data, task.direction & fromOpto);
+
+  if (busState === 0 && task.direction & toOpto && packet.start === 0x16 && 'zero' in packet) {
+    busState = 1;
+  } else if (busState === 1 && task.direction & fromOpto && packet.res === 0x06 && !packet.peek?.length) {
+    busState = 2;
+
+    logger.info('Synchronization completed. Streams are now flowing');
+  }
+
+  if (task.direction & toOpto && packet.addr && !polledAddr.has(packet.addr)) {
+    if (task.direction === fromVitoToOpto && (config.poll_items ?? []).some(([, addr]) => addr === packet.addr)) {
+      logger.info(`Vitoconnect sent a request for address ${formatAddr(packet.addr)}. This address is also on your poll_items list. In order to not waste any bandwidth on the Optolink bus, it is generally recommended to remove this address from the poll_items list and rely on Vitoconnect polling the item instead. This info is only printed once, even though Vitoconnect might continue pulling this item.`);
+    }
+    polledAddr.add(packet.addr);
+  }
+
+  if (packet.id === 0x2) { // UNACK
+    logger.error(`Packet unacknowledged (${formatAddr(packet.addr)})`);
+    return;
+  } else if (packet.id === 0x3) { // ERRMSG
+    logger.error(`Packet with error message (${formatAddr(packet.addr)}):`, packet.data?.toString('hex'));
+    return;
+  } else if (!packet.data || !(
+    // for Virtual_READ (fn = 0x01) and RPCs (fn = 0x07), grab the data from the response (id = 0x1)
+    ((packet.fn === 0x01 || packet.fn === 0x07) && packet.id === 0x1) ||
+    // for Virtual_WRITE (fn = 0x02), grab the data from the request (id = 0x0)
+    (packet.fn === 0x02 && packet.id === 0x0)
+  )) {
+    // ignore any packets that are not reading / writing data
+    return;
+  }
+
+  // special handling for mqtt device discovery, in case no identifiers (serial number) have been specified in the config
+  // we wait for the serial number to be sent by Vitoconnect (0xF010) and then publish the discovery message
+  if (!deviceSerialNo && packet.addr === 0xF010 && (config.mqtt?.device_discovery?.enabled ?? true)) {
+    deviceSerialNo = parseValue('string', packet.data)?.trim?.();
+    await deviceDiscovery();
+  }
+
+  const dp = dps.get(packet.addr);
+  if (!dp && !config.publish_unknown_dps) {
+    logger.debug(`Unknown data point (${formatAddr(packet.addr)}):`, packet.data?.toString('hex'));
+    return;
+  }
+
+  // get the topic and parse the value based on the data point definition, or publish the raw data
+  const topic = mqttDpTopic(dp), value = dp ? dp.parse(packet.data) : packet.data;
+  logger.debug(`Publishing ${dp ? dp.name : 'unknown'} data point (${formatAddr(packet.addr)}) to ${topic}:`, value);
+  await mqttClient.publishAsync(topic, Buffer.isBuffer(value) ? bufferToFormat(value, config.buffer_format ?? 'hex') :
+    `${ typeof value === 'number' ? parseFloat(value.toFixed(config.max_decimals ?? 4 )) : value }`);
+}, 1 /* no concurrency, packets should to be processed in order */);
+packetQueue.error((err, task) => {
+  logger.error(`Error while processing packet: ${task?.data?.toString('hex')}`, err);
+});
+setTimeout(() => {
+  for (const { name, addr } of (dps?.values() ?? []).filter(({ addr }) => !polledAddr.has(addr) && !(config.poll_items ?? []).some(([, pollAddr]) => pollAddr === addr))) {
+    logger.info(`Even after one hour, your data point ${name} with address ${formatAddr(addr)} was never polled from Optolink. This could indicate that Vitoconnect never pulls this item proactively. Consider adding the address to your poll list, so it will be actively polled.`);
+  }
+}, 60 * 60 * 1000); // after 1 hour
+
+// the chunk queue handles each single chunk received from either vito. or opto. side and emit a packet, as soon as the transmit direction changes
+let direction, chunks = [];
+const chunkQueue = async.queue(async task => {
+  if (direction !== task.direction) {
+    if (chunks.length === 1) {
+      packetQueue.push({ data: chunks[0], direction });
+    } else if (chunks.length > 1) {
+      packetQueue.push({ data: Buffer.concat(chunks), direction });
+    }
+
+    direction = task.direction;
+    chunks = [];
+  }
+
+  const { data, packet } = task;
+  if (data || packet) {
+    // special case: in order to keep the order of processed chunks / packets, we need to push pulled packets through the chunk queue as well
+    packetQueue.push({ data, packet, direction });
+  } else {
+    chunks.push(task.chunk);
+  }
+}, 1 /* no concurrency, chunks need to be processed in order */);
+chunkQueue.error((err, task) => {
+  logger.error('Error while processing chunk:', err);
+});
+
+// the intercept function is only called, in case poll_items have been defined. this intercept takes care of injecting poll requests to the message flow
+let nextPoll, pollCallback, pollChunks = [];
+function interceptPolling(chunk, direction, emitCallback, { vitoPort, optoPort, callback }) {
+  if (direction === fromOptoToVito) {
+    if (!pollCallback) {
+      // if we are in the response cycle (data from opto. to vito.),
+      // determine if (on next request cycle), we should inject a poll request
+      // attention: multiple chunks may flow in the same direction multiple times!
+      !nextPoll && busState === 2 && (nextPoll = pollQueue.dequeue());
+      emitCallback(); // then call the callback, so the data is actually forwarded to the vito. and the next request cycle can start
+    } else {      
+      // there is a poll callback, meaning the previous request was a poll request,
+      // so this is our result, don't forward it and collect the chunks of the result
+      pollChunks.push(chunk);
+      // call the raw callback (not the emitCallback!) to continue the serial pipeline,
+      // but do not pass any data back to the vito., as this is our packet!
+      callback(null, Buffer.alloc(0));
+
+      try { // continue reading until we received a valid packet
+        const packet = parsePacket(Buffer.concat(pollChunks), true);
+        if (packet.res === 0x06 && !packet.peek?.length) {
+          return; // it is just the ACK so far, continue reading
+        }
+
+        // put the (already parsed) packet into the packet queue
+        // note: we pass the packet through the chunk queue, in order to uphold the order of packets
+        chunkQueue.push({ packet, direction: fromOptoToLocal });
+
+        // continue by sending the next call from vito. to opto.
+        const contCallback = pollCallback;
+        nextPoll = pollCallback = undefined;
+        pollChunks = []; // reset the chunks, as we have received a full packet
+        contCallback();
+      } catch (err) {
+        // nothing to do here, assume we have not received the full packet yet
+        logger.debug('Parsing polled packet failed:', err.message);
+      }
+    }
+  } else { // vito. to opto.
+    if (!nextPoll) {
+      // there is nothing to poll, so callback immediately to initiate the next vito. to opto. request
+      emitCallback();
+    } else {
+      // there is an item we should poll, so don't send the current request to optolink, but inject our request
+      // instead and remember the current / next poll callback
+      pollCallback = emitCallback;
+
+      const packet = {
+        start: 0x41, // VS2
+        id: 0x0, // REQ
+        seq: 0, // no sequence no.
+        fn: 0x01, // Virtual_READ
+        ...nextPoll // addr and dlen
+      };
+
+      // put the packet into the packet queue
+      // note: we pass the packet through the chunk queue, in order to uphold the order of packets
+      chunkQueue.push({ packet, direction: fromLocalToOpto });
+
+      // push the chunk to the reading side of the serial connection
+      optoPort.write(encodePacket(packet));
+    }
+  }
+}
+
+// this is the main "magic", connecting to both serial ports and handling the data flow
+const serial = await connect(config.port_vito ?? '/dev/ttyS0', config.port_opto ?? '/dev/ttyUSB0',
+  config.poll_items?.length && interceptPolling);
+serial.on('chunk', function(chunk, direction) {
+  chunkQueue.push({ chunk, direction });
+});
+serial.on('error', function(err, direction) {
+  logger.error(`Error on serial port ${directionName(direction)}:`, err);
+});
+
+logger.info(`Started in ${config.poll_items?.length ? 'intercept' : 'pass-through'} mode, waiting for synchronization`);
+
+// after registering for a chunk event listener, await the pipelines
+await serial.pipeline;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "optolink-bridge",
+  "version": "1.0.0",
+  "description": "Safely bridge the Optolink bus of your Viessmann heating system and publish attributes via MQTT + Home Assistant Device Discovery",
+  "keywords": [
+    "viessmann",
+    "vitoconnect",
+    "vitocal",
+    "vitotronic",
+    "vicare",
+    "optolink",
+    "listener",
+    "splitter",
+    "bridge",
+    "tap",
+    "relay",
+    "bridge",
+    "router",
+    "proxy",
+    "local",
+    "mqtt",
+    "safe",
+    "ha",
+    "home assistant",
+    "homeassistant",
+    "discovery",
+    "device discovery"
+  ],
+  "type": "module",
+  "bin": "./index.js",
+  "scripts": {
+    "start": "node ./index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "author": {
+    "name": "Kristian Kraljic",
+    "email": "kris@kra.lc",
+    "url": "https://kra.lc/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kristian/optolink-bridge.git"
+  },
+  "homepage": "https://github.com/kristian/optolink-bridge",
+  "bugs": {
+    "url": "https://github.com/kristian/optolink-bridge/issues"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "async": "^3.2.6",
+    "binary-parser-encoder-bump": "^2.2.1",
+    "buffer-to-str": "^1.0.0",
+    "change-case": "^5.4.4",
+    "chokidar": "^4.0.3",
+    "mqtt": "^5.14.1",
+    "serialport": "^13.0.0",
+    "smol-toml": "^1.4.2",
+    "yocto-queue": "^1.2.1"
+  },
+  "packageManager": "yarn@4.10.3"
+}

package/parse_vs2.js

@@ -0,0 +1,249 @@
+import { Buffer } from 'node:buffer';
+import { Parser } from 'binary-parser-encoder-bump';
+
+function crc256(data, crc = 0) {
+  for (const byte of data) {
+    crc += byte;
+    crc %= 0x100;
+  }
+  return crc;
+}
+
+function when({ tag, type }) {
+  return {
+    tag: function() {
+      return tag.apply(this) ? 1 : 0;
+    },
+    defaultChoice: new Parser(), // nothing
+    choices: {
+      1: type
+    }
+  }
+}
+
+/**
+ * @returns a function that can be used for readUntil, to only peek a single byte (if any)
+ */
+function peek() {
+  return function() {
+    if (!this.peeked) {
+      this.peeked = true;
+      return false;
+    } else {
+      delete this.peeked;
+      return true;
+    }
+  };
+}
+
+const parser = new Parser()
+  .useContextVars()
+  .uint8('start')
+  .choice({
+    tag: 'start',
+    choices: {
+      0x04: new Parser(), // EOT (end of transmission / sync. start)
+      0x16: new Parser() // SYN (synchronous idle / start of transmission)
+        .uint16('zero', {
+          assert: function(zero) {
+            return !zero; // has to start with 16 00 00 (zero!)
+          }
+        }),
+      0x41: new Parser() // VS2_DAP_STANDARD (packet start)
+        .uint8('len')
+        .saveOffset('crc')
+        .pointer('raw', {
+          offset: 'crc',
+          type: new Parser()
+            .buffer('hoist', { length: '$parent.len' }),
+          formatter: struct => struct.hoist
+        })
+        .bit4('unused')
+        .bit4('id')
+        .choice({
+          tag: 'id',
+          choices: {
+            0x0: new Parser(), // REQ
+            0x1: new Parser(), // RESP
+            0x2: new Parser(), // UNACK
+            0x3: new Parser() // ERRMSG
+          }
+        })
+        .bit3('seq')
+        .bit5('fn')
+        .choice({
+          tag: 'fn',
+          choices: {
+            0x01: new Parser(), // Virtual_READ
+            0x02: new Parser(), // Virtual_WRITE
+            0x07: new Parser() // Remote_Procedure_Call
+          }
+        })
+        .uint16be('addr') // addresses are specified in big-endian, while values are little-endian
+        .uint8('dlen') // data length
+        .choice(when({
+          tag: function() {
+            // when reading (fn = 0x01) grab data from the response (id = 0x1), when writing (fn = 0x02) from the request (id = 0x0),
+            // for rpcs (fn = 0x07) it is function input & output (so both req / res have data), for errors (0x3) the data is err. msg
+            return (this.fn === 0x01 && this.id === 0x1) || (this.fn === 0x02 && this.id === 0x0) || (this.fn === 0x07) || (this.id === 0x3);
+          },
+          type: new Parser()
+            .buffer('data', { length: 'dlen' })
+        }))
+        .uint8('crc', {
+          type: 'uint8',
+          assert: function(crc) {
+            // if raw is not set / empty, we are in the encoding case, CRC will be calculated in the encode function
+            return !this.raw?.length || crc256(this.raw, this.len) === crc;
+          }
+        })
+        .buffer('rest', {
+          readUntil: 'eof',
+          assert: function(rest) {
+            return !rest.length;
+          }
+        })
+    }
+  });
+
+const responseParser = new Parser()
+  .useContextVars()
+  .uint8('res')
+  .choice({
+    tag: 'res',
+    choices: {
+      0x05: new Parser(), // ENQ (enquiry / sync. end)
+      0x06: new Parser() // ACK
+        .saveOffset('peek')
+        .pointer('peek', { // corner case: during the handshake, single ACK (0x06) without any data, so peek for one byte
+          offset: 'peek',
+          type: new Parser()
+            .buffer('hoist', {
+              readUntil: peek(),
+              encoder: function() {
+                return Buffer.from(this.start ? [0xFF] : []);
+              }
+            }),
+          formatter: struct => struct.hoist
+        })
+        .choice({
+          tag: 'peek.length',
+          defaultChoice: parser,
+          choices: {
+            0: new Parser()
+          }
+        }),
+      0x15: new Parser() // NACK
+    }
+  });
+
+/**
+ * Parse the VS2 / 300 Optolink protocol packet.
+ * 
+ * @param {Buffer} data the data of the packet to parse
+ * @param {boolean} [response] true in case it was a response (Optolink -> Vitoconnect) packet
+ * @returns {object} the parsed data packet
+ */
+export function parsePacket(data, response) {
+  return (response ? responseParser : parser).parse(data);
+}
+
+// make parsing the default
+export default parsePacket;
+
+const emptyBuffer = Buffer.allocUnsafe(0);
+export function encodePacket(packet, response) {
+  const data = (response ? responseParser : parser).encode(Object.assign({}, packet, {
+    peek: 'start' in packet || 'zero' in packet ? Buffer.from([0xFF]) : emptyBuffer,
+    unused: packet.unused ?? 0,
+    len: packet.len ?? ((packet.data ? packet.data.length : 0) + /* 1/2 unused, 1/2 id, 3/8 seq, 5/8 fn, 2x addr, dlen */ 5),
+    dlen: packet.dlen ?? (packet.data ? packet.data.length : 0),
+    raw: emptyBuffer,
+    rest: emptyBuffer,
+    crc: 0
+  }));
+  
+  return packet.start === 0x41 ? Buffer.concat([data.subarray(0, data.length - 1), Buffer.from([
+    crc256(data.subarray(/* start byte */ 1 + (response ? /* res byte */ 1 : 0), data.length - /* crc byte */ 1))
+  ])]) : data;
+}
+
+/**
+ * All types supported by binary-parser
+ */
+export const types = Object.fromEntries([
+  'uint8', 'int8',
+  ...['u', ''].flatMap(prefix => [
+    ...[16, 32, 64].flatMap(size => [
+      `${prefix}int${size}`, `${prefix}int${size}le`, `${prefix}int${size}be`
+    ])
+  ]),
+  ...['float', 'double'].flatMap(type => [
+    `${type}le`, `${type}be`
+  ]),
+  ...Array.from({ length: 32 }, (value, length) => `bit${length + 1}`),
+  'string', 'buffer'
+].map(type => [type, undefined]));
+
+const valueParser = new Parser()
+  .uint8('type')
+  .choice({
+    tag: 'type',
+    choices: Object.fromEntries(Object.keys(types).map((type, index) => [
+      index, (() => {
+        const parser = new Parser().endianess('little');
+
+        let options;
+        if (type === 'string') {
+          options = { greedy: true };
+        } else if (type === 'buffer') {
+          options = { readUntil: 'eof' };
+        }
+
+        parser[type].call(parser, 'value', options);
+        types[type] = parser.sizeOf(); // length of the data type / dlen
+        return parser;
+      })()]))
+  });
+
+/**
+ * Parses the given value of the specified type.
+ * 
+ * @param {string} [type] the type to parse, one of `types` / all supported types of binary-parser, or 'debug' for all possible types
+ * @param {Buffer} data the data to parse for the given type
+ * @returns {(any|object)} the parsed value, or in case no type was given, an object of all possible types matching the types length (fuzzy, types that are one byte short [e.g. int8 + status byte] will also match, ignoring the last byte of data)
+ */
+export function parseValue(type, data) {
+  if (type === 'debug' || typeof type !== 'string' && (data = type)) {
+    // debug mode: return all possible types fitting for the given data length
+    return Object.fromEntries(Object.entries(types).filter(([type, length]) =>
+        length === data.length || length === data.length - 1 || type === 'buffer' || type === 'string')
+      .map(([type]) => [type, parseValue(type, data)]));
+  } else if (type === 'raw' || type === 'byte') { // aliases for buffer
+    type = 'buffer';
+  } else if (type === 'utf8') { // alias for string
+    type = 'string';
+  } else if (type === 'int' || type === 'uint') {
+    let length = data.length;
+    if (length <= 0) {
+      throw new Error(`Minimum length for (u)int types is 1, got ${length}`)
+    } else if (length > 2 && (length % 2) !== 0) {
+      length--; // remove status bit, 3 -> 2, 5 -> 4, 9 -> 8
+    }
+
+    if ((length & (length - 1)) !== 0) { // must be power of 2: 1, 2, 4, 8
+      throw new Error(`Length of (u)int types must be power of 2 (1 / 2 / 4 / 8), got ${length}`)
+    } else if (length > 8) {
+      throw new Error(`Maximum length for (u)int types is 8, got ${length}`);
+    }
+
+    type = `${type}${length * 8}`;
+  }
+
+  const index = Object.keys(types).indexOf(type);
+  if (index === -1) {
+    throw new Error(`Unknown data type ${type}`);
+  }
+
+  return valueParser.parse(Buffer.from([Object.keys(types).indexOf(type), ...data])).value;
+}