@ukeyfe/hardware-transport-lowlevel 1.1.13

package/README.md

@@ -0,0 +1,29 @@
+# `@ukeyfe/hardware-transport-lowlevel`
+
+`@ukeyfe/hardware-transport-http` is a library that implements transport communication using http.
+
+## What is the purpose
+
+- translate JSON payloads to binary messages using protobuf definitions comprehensible to UKey devices
+- chunking and reading chunked messages according to the [UKey protocol](./protocol.md)
+- exposing single API for various transport methods:
+  - Http Transport
+  - React Native Transport
+  - WebUSB
+- Create and expose typescript definitions based on protobuf definitions.
+
+### The short version
+
+In order to be able to use new features of ukey-firmware you need to update protobuf definitions.
+
+1. `git submodule update --init --recursive` to initialize git submodules.
+1. `yarn update-submodules` to update firmware submodule
+1. `yarn update:protobuf` to generate new `./messages.json` and `./src/types/messages.ts`
+
+git submodule update --init --recursive to initialize firmware submodule
+yarn update-submodules to update firmware submodule
+yarn update:protobuf to generate new ./messages.json and ./src/types/messages.ts
+
+## Docs
+
+Documentation is available [hardware-js-sdk](https://developer.ukey.so/connect-to-hardware/hardware-sdk/start)

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import * as _ukeyfe_hardware_transport from '@ukeyfe/hardware-transport';
+import _ukeyfe_hardware_transport__default, { LowlevelTransportSharedPlugin } from '@ukeyfe/hardware-transport';
+import EventEmitter from 'events';
+
+type LowLevelAcquireInput = {
+    uuid: string;
+};
+
+declare class LowlevelTransport {
+    _messages: ReturnType<typeof _ukeyfe_hardware_transport__default.parseConfigure> | undefined;
+    configured: boolean;
+    Log?: any;
+    emitter?: EventEmitter;
+    plugin: LowlevelTransportSharedPlugin;
+    init(logger: any, emitter: EventEmitter, plugin: LowlevelTransportSharedPlugin): void;
+    configure(signedData: any): void;
+    listen(): void;
+    enumerate(): Promise<_ukeyfe_hardware_transport.LowLevelDevice[]>;
+    acquire(input: LowLevelAcquireInput): Promise<{
+        uuid: string;
+    }>;
+    release(uuid: string): Promise<boolean>;
+    call(uuid: string, name: string, data: Record<string, unknown>): Promise<_ukeyfe_hardware_transport.MessageFromUKey>;
+    cancel(): void;
+}
+
+export { LowlevelTransport as default };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,SAA8B,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAIpD,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,MAAM,EAAE,6BAA6B,CAAuC;IAE5E,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,6BAA6B;IAO9E,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,MAAM;IAIN,SAAS;IAIH,OAAO,CAAC,KAAK,EAAE,oBAAoB;;;IAanC,OAAO,CAAC,IAAI,EAAE,MAAM;IAUpB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAuCpE,MAAM;CAGP"}

package/dist/index.js

@@ -0,0 +1,131 @@
+'use strict';
+
+var hardwareShared = require('@ukeyfe/hardware-shared');
+var transport = require('@ukeyfe/hardware-transport');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var transport__default = /*#__PURE__*/_interopDefaultLegacy(transport);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const { check, buildBuffers, receiveOne, parseConfigure } = transport__default["default"];
+class LowlevelTransport {
+    constructor() {
+        this.configured = false;
+        this.plugin = {};
+    }
+    init(logger, emitter, plugin) {
+        this.Log = logger;
+        this.emitter = emitter;
+        this.plugin = plugin;
+        this.plugin.init();
+    }
+    configure(signedData) {
+        const messages = parseConfigure(signedData);
+        this.configured = true;
+        this._messages = messages;
+    }
+    listen() {
+    }
+    enumerate() {
+        return this.plugin.enumerate();
+    }
+    acquire(input) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.plugin.connect(input.uuid);
+                return { uuid: input.uuid };
+            }
+            catch (error) {
+                this.Log.debug('lowlelvel transport connect error: ', error);
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.LowlevelTrasnportConnectError, (_a = error.message) !== null && _a !== void 0 ? _a : error);
+            }
+        });
+    }
+    release(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.plugin.disconnect(uuid);
+                return true;
+            }
+            catch (error) {
+                this.Log.debug('lowlelvel transport disconnect error: ', error);
+                return false;
+            }
+        });
+    }
+    call(uuid, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._messages === null || !this._messages) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const messages = this._messages;
+            if (transport.LogBlockCommand.has(name)) {
+                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name);
+            }
+            else {
+                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' data: ', data);
+            }
+            const buffers = buildBuffers(messages, name, data);
+            for (const o of buffers) {
+                const outData = o.toString('hex');
+                this.Log.debug('send hex strting: ', outData);
+                try {
+                    yield this.plugin.send(uuid, outData);
+                }
+                catch (e) {
+                    this.Log.debug('lowlevel transport send error: ', e);
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleWriteCharacteristicError, e.reason);
+                }
+            }
+            try {
+                const response = yield this.plugin.receive();
+                if (typeof response !== 'string') {
+                    throw new Error('Returning data is not string');
+                }
+                this.Log.debug('receive data: ', response);
+                const jsonData = receiveOne(messages, response);
+                return check.call(jsonData);
+            }
+            catch (e) {
+                this.Log.error('lowlevel call error: ', e);
+                throw e;
+            }
+        });
+    }
+    cancel() {
+        this.Log.debug('lowlevel-transport', 'cancel');
+    }
+}
+
+module.exports = LowlevelTransport;

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export type LowLevelAcquireInput = {
+    uuid: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@ukeyfe/hardware-transport-lowlevel",
+  "version": "1.1.13",
+  "homepage": "https://github.com/UKeyHQ/hardware-js-sdk#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bestyourwallet/hardware-js-sdk"
+  },
+  "scripts": {
+    "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
+    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "dependencies": {
+    "@ukeyfe/hardware-shared": "1.1.13",
+    "@ukeyfe/hardware-transport": "1.1.13"
+  }
+}

package/src/index.ts

@@ -0,0 +1,106 @@
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import transport, { LogBlockCommand } from '@ukeyfe/hardware-transport';
+import type EventEmitter from 'events';
+import type { LowlevelTransportSharedPlugin } from '@ukeyfe/hardware-transport';
+import type { LowLevelAcquireInput } from './types';
+
+const { check, buildBuffers, receiveOne, parseConfigure } = transport;
+
+export default class LowlevelTransport {
+  _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+
+  configured = false;
+
+  Log?: any;
+
+  emitter?: EventEmitter;
+
+  plugin: LowlevelTransportSharedPlugin = {} as LowlevelTransportSharedPlugin;
+
+  init(logger: any, emitter: EventEmitter, plugin: LowlevelTransportSharedPlugin) {
+    this.Log = logger;
+    this.emitter = emitter;
+    this.plugin = plugin;
+    this.plugin.init();
+  }
+
+  configure(signedData: any) {
+    const messages = parseConfigure(signedData);
+    this.configured = true;
+    this._messages = messages;
+  }
+
+  listen() {
+    // empty
+  }
+
+  enumerate() {
+    return this.plugin.enumerate();
+  }
+
+  async acquire(input: LowLevelAcquireInput) {
+    try {
+      await this.plugin.connect(input.uuid);
+      return { uuid: input.uuid };
+    } catch (error) {
+      this.Log.debug('lowlelvel transport connect error: ', error);
+      throw ERRORS.TypedError(
+        HardwareErrorCode.LowlevelTrasnportConnectError,
+        error.message ?? error
+      );
+    }
+  }
+
+  async release(uuid: string) {
+    try {
+      await this.plugin.disconnect(uuid);
+      return true;
+    } catch (error) {
+      this.Log.debug('lowlelvel transport disconnect error: ', error);
+      return false;
+    }
+  }
+
+  async call(uuid: string, name: string, data: Record<string, unknown>) {
+    if (this._messages === null || !this._messages) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+
+    const messages = this._messages;
+    if (LogBlockCommand.has(name)) {
+      this.Log.debug('lowlevel-transport', 'call-', ' name: ', name);
+    } else {
+      this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' data: ', data);
+    }
+
+    const buffers = buildBuffers(messages, name, data);
+    for (const o of buffers) {
+      const outData = o.toString('hex');
+      // Upload resources on low-end phones may OOM
+      this.Log.debug('send hex strting: ', outData);
+      try {
+        await this.plugin.send(uuid, outData);
+      } catch (e) {
+        this.Log.debug('lowlevel transport send error: ', e);
+        throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError, e.reason);
+      }
+    }
+
+    try {
+      const response = await this.plugin.receive();
+      if (typeof response !== 'string') {
+        throw new Error('Returning data is not string');
+      }
+      this.Log.debug('receive data: ', response);
+      const jsonData = receiveOne(messages, response);
+      return check.call(jsonData);
+    } catch (e) {
+      this.Log.error('lowlevel call error: ', e);
+      throw e;
+    }
+  }
+
+  cancel() {
+    this.Log.debug('lowlevel-transport', 'cancel');
+  }
+}

package/src/types.ts

@@ -0,0 +1,3 @@
+export type LowLevelAcquireInput = {
+  uuid: string;
+};

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+  },
+  "include": ["./src"]
+}