@ukeyfe/hardware-transport 1.1.13

package/scripts/protobuf-patches/index.js

@@ -0,0 +1,274 @@
+const fs = require('fs');
+const path = require('path');
+
+const UINT_TYPE = 'UintType';
+
+// type rule fixes, ideally it should not be here
+const RULE_PATCH = {
+  'MultisigRedeemScriptType.nodes': 'optional', // its valid to be undefined according to implementation/tests
+  'MultisigRedeemScriptType.address_n': 'optional', // its valid to be undefined according to implementation/tests
+  'TxRequestDetailsType.request_index': 'required',
+  'TxRequest.request_type': 'required',
+  'TxRequest.details': 'required',
+  'TxAckPaymentRequest.memos': 'optional', // protobuf repeated bytes are always optional (fallback to [])
+  'CardanoPoolOwnerType.staking_key_path': 'optional',
+  'CardanoPoolOwner.staking_key_path': 'optional',
+  'CardanoTxCertificateType.path': 'optional',
+  'CardanoTxCertificate.path': 'optional',
+  'CardanoTxInputType.address_n': 'optional',
+  'CardanoTxWithdrawal.path': 'optional',
+  'CardanoNativeScript.scripts': 'optional',
+  'CardanoNativeScript.key_path': 'optional',
+  'CardanoTxRequiredSigner.key_path': 'optional',
+  'Success.message': 'required', // didn't find use case where it's not sent
+  'SignedIdentity.address': 'required',
+  'EosAuthorizationKey.key': 'required', // its valid to be undefined according to implementation/tests
+  'EosAuthorizationKey.type': 'optional', // its valid to be undefined according to implementation/tests
+  'EosAuthorizationKey.address_n': 'optional', // its valid to be undefined according to implementation/tests
+  'EthereumAddress.address': 'required', // address is transformed from legacy type _old_address
+  // TODO: Features should be union: bootloader|normal
+  // fields below are marked as required because of backward compatibility (suite implementation)
+  'Features.vendor': 'required',
+  'Features.bootloader_mode': 'required',
+  'Features.device_id': 'required',
+  'Features.major_version': 'required',
+  'Features.minor_version': 'required',
+  'Features.patch_version': 'required',
+  'Features.pin_protection': 'required',
+  'Features.passphrase_protection': 'required',
+  'Features.language': 'required',
+  'Features.label': 'required',
+  'Features.initialized': 'required',
+  'Features.revision': 'required',
+  'Features.bootloader_hash': 'required',
+  'Features.imported': 'required',
+  'Features.unlocked': 'required',
+  'Features.firmware_present': 'required',
+  'Features.needs_backup': 'required',
+  'Features.flags': 'required',
+  'Features.fw_major': 'required',
+  'Features.fw_minor': 'required',
+  'Features.fw_patch': 'required',
+  'Features.fw_vendor': 'required',
+  'Features.model': 'required',
+  'Features.unfinished_backup': 'required',
+  'Features.no_backup': 'required',
+  'Features.recovery_mode': 'required',
+  'Features.backup_type': 'required',
+  'Features.sd_card_present': 'required',
+  'Features.sd_protection': 'required',
+  'Features.wipe_code_protection': 'required',
+  'Features.session_id': 'required',
+  'Features.passphrase_always_on_device': 'required',
+  'Features.safety_checks': 'required',
+  'Features.auto_lock_delay_ms': 'required',
+  'Features.display_rotation': 'required',
+  'Features.experimental_features': 'required',
+  'GetOwnershipProof.ownership_ids': 'optional', // protobuf repeated bytes are always optional (fallback to [])
+  'NEMTransactionCommon.address_n': 'optional', // no address_n in multisig
+  'NEMTransfer.mosaics': 'optional', // its valid to be undefined according to implementation/tests
+  'NEMMosaicDefinition.networks': 'optional', // never used according to implementation/tests
+  'NEMAggregateModification.modifications': 'optional', // its valid to be undefined according to implementation/tests
+  'StellarAssetType.code': 'required',
+  'StellarPathPaymentStrictReceiveOp.paths': 'optional', // its valid to be undefined according to implementation/tests
+  'StellarPathPaymentStrictSendOp.paths': 'optional', // its valid to be undefined according to implementation/tests
+};
+
+// custom types IN to trezor
+// protobuf lib will handle the translation to required type
+// connect or other 3rd party libs are using compatible types (string as number etc...)
+const TYPE_PATCH = {
+  'Features.bootloader_mode': 'boolean | null',
+  'Features.device_id': 'string | null',
+  'Features.pin_protection': 'boolean | null',
+  'Features.passphrase_protection': 'boolean | null',
+  'Features.language': 'string | null',
+  'Features.label': 'string | null',
+  'Features.initialized': 'boolean | null',
+  'Features.revision': 'string | null',
+  'Features.bootloader_hash': 'string | null',
+  'Features.imported': 'boolean | null',
+  'Features.unlocked': 'boolean | null',
+  'Features.firmware_present': 'boolean | null',
+  'Features.needs_backup': 'boolean | null',
+  'Features.flags': 'number | null',
+  'Features.fw_major': 'number | null',
+  'Features.fw_minor': 'number | null',
+  'Features.fw_patch': 'number | null',
+  'Features.fw_vendor': 'string | null',
+  'Features.unfinished_backup': 'boolean | null',
+  'Features.no_backup': 'boolean | null',
+  'Features.recovery_mode': 'boolean | null',
+  'Features.backup_type': 'BackupType | null',
+  'Features.sd_card_present': 'boolean | null',
+  'Features.sd_protection': 'boolean | null',
+  'Features.wipe_code_protection': 'boolean | null',
+  'Features.session_id': 'string | null',
+  'Features.passphrase_always_on_device': 'boolean | null',
+  'Features.safety_checks': 'SafetyCheckLevel | null',
+  'Features.auto_lock_delay_ms': 'number | null',
+  'Features.display_rotation': 'number | null',
+  'Features.experimental_features': 'boolean | null',
+  'Features.ukey_device_type': 'string | null',
+  'Features.ukey_se_type': 'string | null',
+  'Features.ukey_se01_state': 'string | null',
+  'Features.ukey_se02_state': 'string | null',
+  'Features.ukey_se03_state': 'string | null',
+  'Features.ukey_se04_state': 'string | null',
+  'HDNodePathType.node': 'HDNodeType | string',
+  'FirmwareUpload.payload': 'Buffer | ArrayBuffer',
+  'EthereumGetAddress.encoded_network': 'ArrayBuffer',
+  'EthereumDefinitions.encoded_network': 'ArrayBuffer',
+  'EthereumDefinitions.encoded_token': 'ArrayBuffer',
+  'EthereumSignMessage.encoded_network': 'ArrayBuffer',
+  'EthereumSignTypedHash.encoded_network': 'ArrayBuffer',
+  'CardanoCatalystRegistrationParametersType.nonce': UINT_TYPE,
+  'CardanoPoolParametersType.pledge': UINT_TYPE,
+  'CardanoPoolParametersType.cost': UINT_TYPE,
+  'CardanoPoolParametersType.margin_numerator': UINT_TYPE,
+  'CardanoPoolParametersType.margin_denominator': UINT_TYPE,
+  'CardanoTxCertificate.deposit': UINT_TYPE,
+  'CardanoSignTxInit.ttl': UINT_TYPE,
+  'CardanoSignTxInit.validity_interval_start': UINT_TYPE,
+  'CardanoSignTxInit.total_collateral': UINT_TYPE,
+  'CardanoToken.mint_amount': UINT_TYPE,
+  'CardanoNativeScript.invalid_before': UINT_TYPE,
+  'CardanoNativeScript.invalid_hereafter': UINT_TYPE,
+  'EosAsset.symbol': 'string',
+  'EosPermissionLevel.actor': 'string',
+  'EosPermissionLevel.permission': 'string',
+  'EosAuthorizationKey.key': 'string',
+  'EosActionCommon.account': 'string',
+  'EosActionCommon.name': 'string',
+  'EosActionTransfer.sender': 'string',
+  'EosActionTransfer.receiver': 'string',
+  'EosActionDelegate.sender': 'string',
+  'EosActionDelegate.receiver': 'string',
+  'EosActionUndelegate.sender': 'string',
+  'EosActionUndelegate.receiver': 'string',
+  'EosActionRefund.owner': 'string',
+  'EosActionBuyRam.payer': 'string',
+  'EosActionBuyRam.receiver': 'string',
+  'EosActionBuyRamBytes.payer': 'string',
+  'EosActionBuyRamBytes.receiver': 'string',
+  'EosActionSellRam.account': 'string',
+  'EosActionVoteProducer.voter': 'string',
+  'EosActionVoteProducer.proxy': 'string',
+  'EosActionVoteProducer.producers': 'string',
+  'EosActionUpdateAuth.account': 'string',
+  'EosActionUpdateAuth.permission': 'string',
+  'EosActionUpdateAuth.parent': 'string',
+  'EosActionDeleteAuth.account': 'string',
+  'EosActionDeleteAuth.permission': 'string',
+  'EosActionLinkAuth.account': 'string',
+  'EosActionLinkAuth.code': 'string',
+  'EosActionLinkAuth.type': 'string',
+  'EosActionLinkAuth.requirement': 'string',
+  'EosActionUnlinkAuth.account': 'string',
+  'EosActionUnlinkAuth.code': 'string',
+  'EosActionUnlinkAuth.type': 'string',
+  'EosActionNewAccount.creator': 'string',
+  'EosActionNewAccount.name': 'string',
+  'ResetDevice.backup_type': 'string | number', // BackupType is a enum. in Features displayed as string, in resetDevice method param accepted as number
+  'StellarAssetType.type': '0 | 1 | 2',
+  'StellarSignTx.sequence_number': UINT_TYPE,
+  'StellarSignTx.memo_id': 'string',
+  'StellarSignTx.memo_hash': 'Buffer | string',
+  'StellarCreateAccountOp.starting_balance': UINT_TYPE,
+  'StellarPathPaymentStrictReceiveOp.send_max': UINT_TYPE,
+  'StellarPathPaymentStrictReceiveOp.destination_amount': UINT_TYPE,
+  'StellarPathPaymentStrictSendOp.send_amount': UINT_TYPE,
+  'StellarPathPaymentStrictSendOp.destination_min': UINT_TYPE,
+  'StellarManageSellOfferOp.offer_id': UINT_TYPE,
+  'StellarManageBuyOfferOp.offer_id': UINT_TYPE,
+  'StellarSetOptionsOp.master_weight': UINT_TYPE,
+  'StellarSetOptionsOp.low_threshold': UINT_TYPE,
+  'StellarSetOptionsOp.medium_threshold': UINT_TYPE,
+  'StellarSetOptionsOp.high_threshold': UINT_TYPE,
+  'StellarSetOptionsOp.signer_key': 'Buffer | string',
+  'StellarChangeTrustOp.limit': UINT_TYPE,
+  'StellarManageDataOp.value': 'Buffer | string',
+  'StellarBumpSequenceOp.bump_to': UINT_TYPE,
+  'TezosContractID.tag': 'number',
+  'TezosContractID.hash': 'Uint8Array',
+  'TezosRevealOp.source': 'Uint8Array',
+  'TezosRevealOp.public_key': 'Uint8Array',
+  'TezosParametersManager.set_delegate': 'Uint8Array',
+  'TezosTransactionOp.source': 'Uint8Array',
+  'TezosTransactionOp.parameters': 'number[]',
+  'TezosOriginationOp.source': 'Uint8Array',
+  'TezosOriginationOp.delegate': 'Uint8Array',
+  'TezosOriginationOp.script': 'string | number[]',
+  'TezosDelegationOp.source': 'Uint8Array',
+  'TezosDelegationOp.delegate': 'Uint8Array',
+  'TezosSignTx.branch': 'Uint8Array',
+  'TonSignMessage.ton_amount': UINT_TYPE,
+  'TonSignMessage.jetton_amount': UINT_TYPE,
+  'TonSignMessage.fwd_fee': UINT_TYPE,
+  'TonSignMessage.expire_at': UINT_TYPE,
+  'TonSignMessage.ext_ton_amount': UINT_TYPE,
+  'TonSignProof.expire_at': UINT_TYPE,
+};
+
+const DEFINITION_PATCH = {
+  TxInputType: fs.readFileSync(path.join(__dirname, './TxInputType.js'), 'utf8'),
+  TxOutputType: fs.readFileSync(path.join(__dirname, './TxOutputType.js'), 'utf8'),
+  TxAck: fs.readFileSync(path.join(__dirname, './TxAck.js'), 'utf8'),
+};
+
+// skip unnecessary types
+const SKIP = [
+  'MessageType', // connect uses custom definition
+  'TransactionType', // connect uses custom definition
+  'TxInput', // declared in TxInputType patch
+  'TxOutput', // declared in TxOutputType patch
+  // not implemented
+  'CosiCommit',
+  'CosiCommitment',
+  'CosiSign',
+  'CosiSignature',
+  'DebugSwipeDirection',
+  'DebugLinkDecision',
+  'DebugLinkLayout',
+  'DebugLinkReseedRandom',
+  'DebugLinkRecordScreen',
+  'DebugLinkGetState',
+  'DebugLinkState',
+  'DebugLinkStop',
+  'DebugLinkLog',
+  'DebugLinkMemoryRead',
+  'DebugLinkMemory',
+  'DebugLinkMemoryWrite',
+  'DebugLinkFlashErase',
+  'DebugLinkEraseSdCard',
+  'DebugLinkWatchLayout',
+  'LoadDevice',
+  'DebugMoneroDiagRequest',
+  'DebugMoneroDiagAck',
+  'WebAuthnListResidentCredentials',
+  'WebAuthnAddResidentCredential',
+  'WebAuthnRemoveResidentCredential',
+  'WebAuthnCredential',
+  'WebAuthnCredentials',
+  'wire_in',
+  'wire_out',
+  'wire_debug_in',
+  'wire_debug_out',
+  'wire_tiny',
+  'wire_bootloader',
+  'wire_no_fsm',
+  'bitcoin_only',
+  'has_bitcoin_only_values',
+  'unstable',
+  'wire_type',
+  'experimental',
+  'include_in_bitcoin_only',
+];
+
+module.exports = {
+  RULE_PATCH,
+  TYPE_PATCH,
+  DEFINITION_PATCH,
+  SKIP,
+  UINT_TYPE,
+};

package/scripts/protobuf-types.js

@@ -0,0 +1,283 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+/* eslint-disable import/no-unresolved */
+// flowtype only
+// flowtype doesn't have `enum` declarations like typescript
+
+const fs = require('fs');
+const path = require('path');
+
+const json = require('../messages.json');
+const { RULE_PATCH, TYPE_PATCH, DEFINITION_PATCH, SKIP, UINT_TYPE } = require('./protobuf-patches');
+
+const args = process.argv.slice(2);
+
+const isTypescript = args.includes('typescript');
+
+// proto types to javascript types
+const FIELD_TYPES = {
+  uint32: 'number',
+  uint64: 'number',
+  sint32: 'number',
+  sint64: 'number',
+  bool: 'boolean',
+  bytes: 'string',
+  // 'bytes': 'Uint8Array | number[] | Buffer | string', // protobuf will handle conversion
+};
+
+const types = []; // { type: 'enum | message', name: string, value: string[], exact?: boolean };
+
+// enums used as keys (string), used as values (number) by default
+const ENUM_KEYS = [
+  'InputScriptType',
+  'OutputScriptType',
+  'RequestType',
+  'BackupType',
+  'Capability',
+  'SafetyCheckLevel',
+  'ButtonRequestType',
+  'PinMatrixRequestType',
+  'WordRequestType',
+];
+
+const parseEnumTypescript = (itemName, item) => {
+  const value = [];
+  const IS_KEY = ENUM_KEYS.includes(itemName);
+  // declare enum
+  if (IS_KEY) {
+    value.push(`export enum Enum_${itemName} {`);
+  } else {
+    value.push(`export enum ${itemName} {`);
+  }
+
+  // declare fields
+  Object.entries(item.values).forEach(([name, id]) => {
+    value.push(`    ${name} = ${id},`);
+  });
+  // close enum declaration
+  value.push('}');
+
+  if (IS_KEY) {
+    value.push(`export type ${itemName} = keyof typeof Enum_${itemName};`);
+  }
+  // empty line
+  value.push('');
+
+  types.push({
+    type: 'enum',
+    name: itemName,
+    value: value.join('\n'),
+  });
+};
+
+const parseEnum = (itemName, item) => {
+  if (isTypescript) return parseEnumTypescript(itemName, item);
+  const value = [];
+  // declare enum
+  value.push(`export const Enum_${itemName} = Object.freeze({`);
+  // declare fields
+  Object.entries(item.values).forEach(([name, id]) => {
+    value.push(`    ${name}: ${id},`);
+  });
+  // close enum declaration
+  value.push('});');
+  // declare enum type using Keys or Values
+  const KEY = ENUM_KEYS.includes(itemName) ? 'Keys' : 'Values';
+  value.push(`export type ${itemName} = $${KEY}<typeof Enum_${itemName}>;`);
+  // empty line
+  value.push('');
+
+  types.push({
+    type: 'enum',
+    name: itemName,
+    value: value.join('\n'),
+  });
+};
+
+const useDefinition = def => {
+  // remove flow overhead
+  const clean = def.replace(/\/\/ @flow/, '').replace(/\/\/ @overhead-start(.*)@overhead-end/s, '');
+
+  if (isTypescript) {
+    // use typescript variant
+    // replace flowtype $Exact declaration: {| foo: 1 |} => { foo: 1 }
+    // replace flowtype spread with typescript union: { ...T, foo: 1 } => T & { foo: 1 }, see TxInputType patch
+    return clean
+      .replace(/\/\/ @typescript-variant:/, '')
+      .replace(/\/\/ @flowtype-variant(.*)/, '')
+      .replace(/{\|/gi, '{')
+      .replace(/\|}/gi, '}')
+      .replace(/\{\n.*.\.{3}(.*?),/g, '$1 & {');
+  }
+  return clean.replace(/\/\/ @typescript-variant(.*)/, '').replace(/\/\/ @flowtype-variant:/, '');
+};
+
+const parseMessage = (messageName, message, depth = 0) => {
+  if (messageName === 'google') return;
+  const value = [];
+  // add comment line
+  if (!depth) value.push(`// ${messageName}`);
+  // declare nested enums
+
+  // declare nested values
+  if (message.nested) {
+    Object.keys(message.nested).map(item => parseMessage(item, message.nested[item], depth + 1));
+  }
+
+  if (message.values) {
+    return parseEnum(messageName, message);
+  }
+  if (!message.fields || !Object.keys(message.fields).length) {
+    // few types are just empty objects, make it one line
+    value.push(`export type ${messageName} = {};`);
+    value.push('');
+  } else {
+    // find patch
+    const definition = DEFINITION_PATCH[messageName];
+    if (definition) {
+      // replace whole declaration
+      value.push(useDefinition(definition));
+    } else {
+      // declare type
+      value.push(`export type ${messageName} = {`);
+      Object.keys(message.fields).forEach(fieldName => {
+        const field = message.fields[fieldName];
+        const fieldKey = `${messageName}.${fieldName}`;
+        // find patch for "rule"
+        const fieldRule = RULE_PATCH[fieldKey] || field.rule;
+        const rule = fieldRule === 'required' || fieldRule === 'repeated' ? ': ' : '?: ';
+        // find patch for "type"
+        let type = TYPE_PATCH[fieldKey] || FIELD_TYPES[field.type] || field.type;
+        // automatically convert all amount and fee fields to UINT_TYPE
+        if (['amount', 'fee'].includes(fieldName)) {
+          type = UINT_TYPE;
+        }
+        // array
+        if (field.rule === 'repeated') {
+          type = type.split('|').length > 1 ? `Array<${type}>` : `${type}[]`;
+        }
+        value.push(`    ${fieldName}${rule}${type};`);
+      });
+      // close type declaration
+      value.push('};');
+      // empty line
+      value.push('');
+    }
+  }
+  // type doest have to be e
+  const exact = message.fields && Object.values(message.fields).find(f => f.rule === 'required');
+  types.push({
+    type: 'message',
+    name: messageName,
+    value: value.join('\n'),
+    exact,
+  });
+};
+
+// top level messages and nested messages
+Object.keys(json.nested).map(e => parseMessage(e, json.nested[e]));
+
+// types needs reordering (used before defined)
+const ORDER = {
+  BinanceCoin: 'BinanceInputOutput',
+  HDNodeType: 'HDNodePathType',
+  CardanoAssetGroupType: 'CardanoTxOutputType',
+  CardanoTokenType: 'CardanoAssetGroupType',
+  TxAck: 'TxAckInputWrapper',
+  EthereumFieldType: 'EthereumStructMember',
+  EthereumDataType: 'EthereumFieldType',
+  PaymentRequestMemo: 'TxAckPaymentRequest',
+};
+
+Object.keys(ORDER).forEach(key => {
+  // find indexes
+  const indexA = types.findIndex(t => t && t.name === key);
+  const indexB = types.findIndex(t => t && t.name === ORDER[key]);
+  const prevA = types[indexA];
+  // replace values
+  delete types[indexA];
+  types.splice(indexB, 0, prevA);
+});
+
+// skip not needed types
+SKIP.forEach(key => {
+  const index = types.findIndex(t => t && t.name === key);
+  delete types[index];
+});
+
+// create content from types
+const content = types.flatMap(t => (t ? [t.value] : [])).join('\n');
+
+const lines = []; // string[]
+if (!isTypescript) lines.push('// @flow');
+lines.push('// This file is auto generated from data/messages/message.json');
+lines.push('');
+lines.push('// custom type uint32/64 may be represented as string');
+lines.push(`export type ${UINT_TYPE} = string | number;`);
+lines.push('');
+lines.push(content);
+
+// create custom definition
+if (!isTypescript) {
+  lines.push('// custom connect definitions');
+  lines.push('export type MessageType = {');
+  types
+    .flatMap(t => (t && t.type === 'message' ? [t] : []))
+    .forEach(t => {
+      if (t.exact) {
+        lines.push(`    ${t.name}: $Exact<${t.name}>;`);
+      } else {
+        lines.push(`    ${t.name}: ${t.name};`);
+      }
+      // lines.push('    ' + t.name + ': $Exact<' + t.name + '>;');
+    });
+  lines.push('};');
+
+  // additional types utilities
+  lines.push(`
+export type MessageKey = $Keys<MessageType>;
+
+export type MessageResponse<T: MessageKey> = {
+    type: T;
+    message: $ElementType<MessageType, T>;
+};
+
+export type TypedCall = <T: MessageKey, R: MessageKey>(
+    type: T,
+    resType: R,
+    message?: $ElementType<MessageType, T>
+) => Promise<MessageResponse<R>>;
+`);
+} else {
+  lines.push('// custom connect definitions');
+  lines.push('export type MessageType = {');
+  types
+    .flatMap(t => (t && t.type === 'message' ? [t] : []))
+    .forEach(t => {
+      lines.push(`    ${t.name}: ${t.name};`);
+    });
+  lines.push('};');
+
+  // additional types utilities
+  lines.push(`
+export type MessageKey = keyof MessageType;
+
+export type MessageResponse<T extends MessageKey> = {
+    type: T;
+    message: MessageType[T];
+};
+
+export type TypedCall = <T extends MessageKey, R extends MessageKey>(
+    type: T,
+    resType: R,
+    message?: MessageType[T],
+) => Promise<MessageResponse<R>>;
+`);
+}
+
+// save to file
+const filePath = isTypescript
+  ? path.join(__dirname, '../src/types/messages.ts')
+  : path.join(__dirname, '../protobuf.js');
+fs.writeFile(filePath, lines.join('\n'), err => {
+  if (err) return console.log(err);
+});

package/src/constants.ts

@@ -0,0 +1,8 @@
+export const MESSAGE_TOP_CHAR = 0x003f;
+export const MESSAGE_HEADER_BYTE = 0x23;
+export const HEADER_SIZE = 1 + 1 + 4 + 2;
+export const BUFFER_SIZE = 63;
+/**
+ * exclude ?##
+ */
+export const COMMON_HEADER_SIZE = 6;

package/src/index.ts

@@ -0,0 +1,41 @@
+import * as protobuf from 'protobufjs/light';
+import * as Long from 'long';
+import {
+  buildBuffers,
+  buildEncodeBuffers,
+  buildOne,
+  decodeProtocol,
+  parseConfigure,
+  receiveOne,
+} from './serialization';
+import * as check from './utils/highlevel-checks';
+
+protobuf.util.Long = Long;
+protobuf.configure();
+
+export type {
+  Transport,
+  AcquireInput,
+  UKeyDeviceInfo,
+  UKeyMobileDeviceInfo,
+  UKeyDeviceInfoWithSession,
+  MessageFromUKey,
+  LowlevelTransportSharedPlugin,
+  LowLevelDevice,
+} from './types';
+
+export { Messages } from './types';
+export * from './types/messages';
+export * from './utils/logBlockCommand';
+
+export * from './constants';
+
+export default {
+  check,
+  buildOne,
+  buildBuffers,
+  buildEncodeBuffers,
+  receiveOne,
+  parseConfigure,
+  decodeProtocol,
+};

package/src/serialization/index.ts

@@ -0,0 +1,8 @@
+import { parseConfigure } from './protobuf';
+
+export * from './send';
+export * from './receive';
+
+export * as decodeProtocol from './protocol/decode';
+
+export { parseConfigure };