@ukeyfe/hardware-transport-http 1.1.13

package/README.md

@@ -0,0 +1,29 @@
+# `@ukeyfe/hardware-transport-http`
+
+`@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
+yar 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/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_URL = "http://localhost:21320";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,2BAA2B,CAAC"}

package/dist/http.d.ts

@@ -0,0 +1,8 @@
+export type HttpRequestOptions = {
+    body?: Array<any> | Record<string, unknown> | string;
+    url: string;
+    method: 'POST' | 'GET';
+    timeout?: number;
+};
+export declare function request(options: HttpRequestOptions): Promise<any>;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;IACrD,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AA4BF,wBAAsB,OAAO,CAAC,OAAO,EAAE,kBAAkB,gBA+CxD"}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import * as _ukeyfe_hardware_transport from '@ukeyfe/hardware-transport';
+import _ukeyfe_hardware_transport__default, { UKeyDeviceInfoWithSession, AcquireInput } from '@ukeyfe/hardware-transport';
+
+type IncompleteRequestOptions = {
+    body?: Array<any> | Record<string, unknown> | string;
+    url: string;
+    timeout?: number;
+};
+declare class HttpTransport {
+    _messages: ReturnType<typeof _ukeyfe_hardware_transport__default.parseConfigure> | undefined;
+    name: string;
+    configured: boolean;
+    stopped: boolean;
+    url: string;
+    Log?: any;
+    constructor(url?: string);
+    _post(options: IncompleteRequestOptions): Promise<any>;
+    init(logger: any): Promise<string>;
+    _silentInit(): Promise<string>;
+    configure(signedData: any): void;
+    listen(old?: Array<UKeyDeviceInfoWithSession>): Promise<UKeyDeviceInfoWithSession[]>;
+    enumerate(): Promise<UKeyDeviceInfoWithSession[]>;
+    _acquireMixed(input: AcquireInput): Promise<any>;
+    acquire(input: AcquireInput): Promise<string>;
+    release(session: string, onclose: boolean): Promise<void>;
+    call(session: string, name: string, data: Record<string, unknown>): Promise<_ukeyfe_hardware_transport.MessageFromUKey>;
+    post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
+    read(session: string): Promise<_ukeyfe_hardware_transport.MessageFromUKey>;
+    requestDevice(): Promise<never>;
+    stop(): void;
+    cancel(): void;
+}
+
+export { HttpTransport as default };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAA8B,MAAM,4BAA4B,CAAC;AAExE,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAM1F,KAAK,wBAAwB,GAAG;IAC9B,IAAI,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;IACrD,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,IAAI,SAAmB;IAEvB,UAAU,UAAS;IAEnB,OAAO,UAAS;IAEhB,GAAG,EAAE,MAAM,CAAC;IAEZ,GAAG,CAAC,EAAE,GAAG,CAAC;gBAEE,GAAG,CAAC,EAAE,MAAM;IAIxB,KAAK,CAAC,OAAO,EAAE,wBAAwB;IAWjC,IAAI,CAAC,MAAM,EAAE,GAAG;IAMhB,WAAW;IAUjB,SAAS,CAAC,UAAU,EAAE,GAAG;IAMnB,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,yBAAyB,CAAC;IAY7C,SAAS;IAMf,aAAa,CAAC,KAAK,EAAE,YAAY;IAS3B,OAAO,CAAC,KAAK,EAAE,YAAY;IAK3B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAUzC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAyBjE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAYjE,IAAI,CAAC,OAAO,EAAE,MAAM;IAe1B,aAAa;IAKb,IAAI;IAIJ,MAAM;CAGP"}

package/dist/index.js

@@ -0,0 +1,276 @@
+'use strict';
+
+var transport = require('@ukeyfe/hardware-transport');
+var hardwareShared = require('@ukeyfe/hardware-shared');
+var axios = require('axios');
+var secureJSON = require('secure-json-parse');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var transport__default = /*#__PURE__*/_interopDefaultLegacy(transport);
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var secureJSON__default = /*#__PURE__*/_interopDefaultLegacy(secureJSON);
+
+/******************************************************************************
+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;
+};
+
+function contentType(body) {
+    if (typeof body === 'string') {
+        return 'text/plain';
+    }
+    return 'application/json';
+}
+function wrapBody(body) {
+    if (typeof body === 'string') {
+        return body;
+    }
+    return JSON.stringify(body);
+}
+function parseResult(text) {
+    try {
+        const result = secureJSON__default["default"].parse(text);
+        if (typeof result !== 'object') {
+            throw new Error('Invalid response');
+        }
+        return result;
+    }
+    catch (e) {
+        return text;
+    }
+}
+function request(options) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const fetchOptions = {
+            url: options.url,
+            method: options.method,
+            data: wrapBody(options.body),
+            withCredentials: false,
+            headers: {
+                'Content-Type': contentType(options.body == null ? '' : options.body),
+            },
+            timeout: (_a = options.timeout) !== null && _a !== void 0 ? _a : undefined,
+            transformResponse: data => data,
+        };
+        try {
+            const res = yield axios__default["default"].request(fetchOptions);
+            if (+res.status === 200) {
+                return parseResult(res.data);
+            }
+            const resJson = parseResult(res.data);
+            if (typeof resJson === 'object' && resJson != null && resJson.error != null) {
+                throw new hardwareShared.HardwareError({
+                    errorCode: hardwareShared.HardwareErrorCode.NetworkError,
+                    message: resJson.error,
+                });
+            }
+            else {
+                throw new hardwareShared.HardwareError({ errorCode: hardwareShared.HardwareErrorCode.NetworkError, message: res.data });
+            }
+        }
+        catch (err) {
+            const axiosErr = err;
+            const respData = (_b = axiosErr === null || axiosErr === void 0 ? void 0 : axiosErr.response) === null || _b === void 0 ? void 0 : _b.data;
+            if (typeof respData === 'string') {
+                const parsed = parseResult(respData);
+                if (typeof parsed === 'object' && parsed !== null && parsed.error) {
+                    throw hardwareShared.CreateHardwareErrorByBridgeError(String(parsed.error));
+                }
+                throw hardwareShared.CreateHardwareErrorByBridgeError(respData);
+            }
+            throw new hardwareShared.HardwareError({
+                errorCode: hardwareShared.HardwareErrorCode.BridgeNetworkError,
+                message: (axiosErr === null || axiosErr === void 0 ? void 0 : axiosErr.message) || 'Bridge network error',
+            });
+        }
+    });
+}
+axios__default["default"].interceptors.request.use((config) => {
+    var _a;
+    if (typeof window !== 'undefined') {
+        return config;
+    }
+    if ((_a = config.url) === null || _a === void 0 ? void 0 : _a.startsWith('http://localhost:21320')) {
+        if (!config.headers.get('Origin')) {
+            config.headers.set('Origin', 'https://jssdk.onekey.so');
+        }
+    }
+    return config;
+});
+
+const DEFAULT_URL = 'http://localhost:21320';
+
+const { check, buildOne, receiveOne, parseConfigure } = transport__default["default"];
+class HttpTransport {
+    constructor(url) {
+        this.name = 'HttpTransport';
+        this.configured = false;
+        this.stopped = false;
+        this.url = url == null ? DEFAULT_URL : url;
+    }
+    _post(options) {
+        if (this.stopped) {
+            return Promise.reject(hardwareShared.ERRORS.TypedError('Transport stopped.'));
+        }
+        return request(Object.assign(Object.assign({}, options), { method: 'POST', url: this.url + options.url }));
+    }
+    init(logger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.Log = logger;
+            const bridgeVersion = yield this._silentInit();
+            return bridgeVersion;
+        });
+    }
+    _silentInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const infoS = yield request({
+                url: this.url,
+                method: 'POST',
+                timeout: 3000,
+            });
+            const info = check.info(infoS);
+            return info.version;
+        });
+    }
+    configure(signedData) {
+        const messages = parseConfigure(signedData);
+        this.configured = true;
+        this._messages = messages;
+    }
+    listen(old) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (old === null) {
+                throw hardwareShared.ERRORS.TypedError('Http-Transport does not support listen without previous.');
+            }
+            const devicesS = yield this._post({
+                url: '/listen',
+                body: old,
+            });
+            const devices = check.devices(devicesS);
+            return devices;
+        });
+    }
+    enumerate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devicesS = yield this._post({ url: '/enumerate' });
+            const devices = check.devices(devicesS);
+            return devices;
+        });
+    }
+    _acquireMixed(input) {
+        const previousStr = input.previous == null ? 'null' : encodeURIComponent(input.previous);
+        const path = encodeURIComponent(input.path);
+        const url = `/acquire/${path}/${previousStr}`;
+        return this._post({ url });
+    }
+    acquire(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const acquireS = yield this._acquireMixed(input);
+            return check.acquire(acquireS);
+        });
+    }
+    release(session, onclose) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = this._post({
+                url: `/release/${session}`,
+            });
+            if (onclose) {
+                return;
+            }
+            yield res;
+        });
+    }
+    call(session, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._messages == null) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const messages = this._messages;
+            if (transport.LogBlockCommand.has(name)) {
+                this.Log.debug('call-', ' name: ', name);
+            }
+            else {
+                this.Log.debug('call-', ' name: ', name, ' data: ', data);
+            }
+            const o = buildOne(messages, name, data);
+            const outData = o.toString('hex');
+            const resData = yield this._post({
+                url: `/call/${session}`,
+                body: outData,
+                timeout: name === 'Initialize' ? 10000 : undefined,
+            });
+            if (typeof resData !== 'string') {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
+            }
+            const jsonData = receiveOne(messages, resData);
+            return check.call(jsonData);
+        });
+    }
+    post(session, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._messages == null) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const messages = this._messages;
+            const outData = buildOne(messages, name, data).toString('hex');
+            yield this._post({
+                url: `/post/${session}`,
+                body: outData,
+            });
+        });
+    }
+    read(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._messages == null) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const messages = this._messages;
+            const resData = yield this._post({
+                url: `/read/${session}`,
+            });
+            if (typeof resData !== 'string') {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
+            }
+            const jsonData = receiveOne(messages, resData);
+            return check.call(jsonData);
+        });
+    }
+    requestDevice() {
+        return Promise.reject();
+    }
+    stop() {
+        this.stopped = true;
+    }
+    cancel() {
+        this.Log.debug('canceled');
+    }
+}
+
+module.exports = HttpTransport;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ukeyfe/hardware-transport-http",
+  "version": "1.1.13",
+  "description": "hardware http transport",
+  "author": "UKey",
+  "homepage": "https://github.com/UKeyHQ/hardware-js-sdk#readme",
+  "license": "ISC",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bestyourwallet/hardware-js-sdk"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "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"
+  },
+  "bugs": {
+    "url": "https://github.com/UKeyHQ/hardware-js-sdk/issues"
+  },
+  "dependencies": {
+    "@ukeyfe/hardware-shared": "1.1.13",
+    "@ukeyfe/hardware-transport": "1.1.13",
+    "axios": "1.12.2",
+    "secure-json-parse": "^4.0.0"
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_URL = 'http://localhost:21320';

package/src/http.ts

@@ -0,0 +1,103 @@
+import axios, { AxiosError, AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios';
+import {
+  HardwareError,
+  HardwareErrorCode,
+  CreateHardwareErrorByBridgeError,
+} from '@ukeyfe/hardware-shared';
+import secureJSON from 'secure-json-parse';
+
+export type HttpRequestOptions = {
+  body?: Array<any> | Record<string, unknown> | string;
+  url: string;
+  method: 'POST' | 'GET';
+  timeout?: number;
+};
+
+function contentType(body: any) {
+  if (typeof body === 'string') {
+    return 'text/plain';
+  }
+  return 'application/json';
+}
+
+function wrapBody(body: any) {
+  if (typeof body === 'string') {
+    return body;
+  }
+  return JSON.stringify(body);
+}
+
+function parseResult(text: string) {
+  try {
+    const result = secureJSON.parse(text);
+    if (typeof result !== 'object') {
+      throw new Error('Invalid response');
+    }
+    return result;
+  } catch (e) {
+    return text;
+  }
+}
+
+export async function request(options: HttpRequestOptions) {
+  const fetchOptions: AxiosRequestConfig = {
+    url: options.url,
+    method: options.method,
+    data: wrapBody(options.body),
+    withCredentials: false,
+    headers: {
+      'Content-Type': contentType(options.body == null ? '' : options.body),
+    },
+    timeout: options.timeout ?? undefined,
+    // Prevent string from converting to number
+    // see https://stackoverflow.com/questions/43787712/axios-how-to-deal-with-big-integers
+    transformResponse: data => data,
+  };
+
+  try {
+    const res = await axios.request(fetchOptions);
+
+    if (+res.status === 200) {
+      return parseResult(res.data);
+    }
+    const resJson = parseResult(res.data);
+    if (typeof resJson === 'object' && resJson != null && resJson.error != null) {
+      throw new HardwareError({
+        errorCode: HardwareErrorCode.NetworkError,
+        message: resJson.error,
+      });
+    } else {
+      throw new HardwareError({ errorCode: HardwareErrorCode.NetworkError, message: res.data });
+    }
+  } catch (err) {
+    const axiosErr = err as AxiosError<string>;
+    const respData = axiosErr?.response?.data;
+
+    if (typeof respData === 'string') {
+      const parsed = parseResult(respData);
+      if (typeof parsed === 'object' && parsed !== null && parsed.error) {
+        throw CreateHardwareErrorByBridgeError(String(parsed.error));
+      }
+      throw CreateHardwareErrorByBridgeError(respData);
+    }
+
+    throw new HardwareError({
+      errorCode: HardwareErrorCode.BridgeNetworkError,
+      message: axiosErr?.message || 'Bridge network error',
+    });
+  }
+}
+
+axios.interceptors.request.use((config: InternalAxiosRequestConfig) => {
+  if (typeof window !== 'undefined') {
+    return config;
+  }
+  // node environment
+  if (config.url?.startsWith('http://localhost:21320')) {
+    if (!config.headers.get('Origin')) {
+      // add Origin field for request headers
+      config.headers.set('Origin', 'https://jssdk.onekey.so');
+    }
+  }
+  return config;
+});

package/src/index.ts

@@ -0,0 +1,171 @@
+import transport, { LogBlockCommand } from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import type { AcquireInput, UKeyDeviceInfoWithSession } from '@ukeyfe/hardware-transport';
+import { request as http } from './http';
+import { DEFAULT_URL } from './constants';
+
+const { check, buildOne, receiveOne, parseConfigure } = transport;
+
+type IncompleteRequestOptions = {
+  body?: Array<any> | Record<string, unknown> | string;
+  url: string;
+  timeout?: number;
+};
+
+export default class HttpTransport {
+  _messages: ReturnType<typeof transport.parseConfigure> | undefined;
+
+  name = 'HttpTransport';
+
+  configured = false;
+
+  stopped = false;
+
+  url: string;
+
+  Log?: any;
+
+  constructor(url?: string) {
+    this.url = url == null ? DEFAULT_URL : url;
+  }
+
+  _post(options: IncompleteRequestOptions) {
+    if (this.stopped) {
+      return Promise.reject(ERRORS.TypedError('Transport stopped.'));
+    }
+    return http({
+      ...options,
+      method: 'POST',
+      url: this.url + options.url,
+    });
+  }
+
+  async init(logger: any) {
+    this.Log = logger;
+    const bridgeVersion = await this._silentInit();
+    return bridgeVersion;
+  }
+
+  async _silentInit() {
+    const infoS = await http({
+      url: this.url,
+      method: 'POST',
+      timeout: 3000,
+    });
+    const info = check.info(infoS);
+    return info.version;
+  }
+
+  configure(signedData: any) {
+    const messages = parseConfigure(signedData);
+    this.configured = true;
+    this._messages = messages;
+  }
+
+  async listen(old?: Array<UKeyDeviceInfoWithSession>) {
+    if (old === null) {
+      throw ERRORS.TypedError('Http-Transport does not support listen without previous.');
+    }
+    const devicesS = await this._post({
+      url: '/listen',
+      body: old,
+    });
+    const devices = check.devices(devicesS);
+    return devices;
+  }
+
+  async enumerate() {
+    const devicesS = await this._post({ url: '/enumerate' });
+    const devices = check.devices(devicesS);
+    return devices;
+  }
+
+  _acquireMixed(input: AcquireInput) {
+    const previousStr = input.previous == null ? 'null' : encodeURIComponent(input.previous);
+    // @ts-expect-error
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    const path = encodeURIComponent(input.path);
+    const url = `/acquire/${path}/${previousStr}`;
+    return this._post({ url });
+  }
+
+  async acquire(input: AcquireInput) {
+    const acquireS = await this._acquireMixed(input);
+    return check.acquire(acquireS);
+  }
+
+  async release(session: string, onclose: boolean) {
+    const res = this._post({
+      url: `/release/${session}`,
+    });
+    if (onclose) {
+      return;
+    }
+    await res;
+  }
+
+  async call(session: string, name: string, data: Record<string, unknown>) {
+    if (this._messages == null) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    const messages = this._messages;
+    if (LogBlockCommand.has(name)) {
+      this.Log.debug('call-', ' name: ', name);
+    } else {
+      this.Log.debug('call-', ' name: ', name, ' data: ', data);
+    }
+
+    const o = buildOne(messages, name, data);
+    const outData = o.toString('hex');
+    const resData = await this._post({
+      url: `/call/${session}`,
+      body: outData,
+      timeout: name === 'Initialize' ? 10000 : undefined,
+    });
+    if (typeof resData !== 'string') {
+      throw ERRORS.TypedError(HardwareErrorCode.NetworkError, 'Returning data is not string.');
+    }
+    const jsonData = receiveOne(messages, resData);
+    return check.call(jsonData);
+  }
+
+  async post(session: string, name: string, data: Record<string, unknown>) {
+    if (this._messages == null) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    const messages = this._messages;
+    const outData = buildOne(messages, name, data).toString('hex');
+    await this._post({
+      url: `/post/${session}`,
+      body: outData,
+    });
+  }
+
+  async read(session: string) {
+    if (this._messages == null) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    const messages = this._messages;
+    const resData = await this._post({
+      url: `/read/${session}`,
+    });
+    if (typeof resData !== 'string') {
+      throw ERRORS.TypedError(HardwareErrorCode.NetworkError, 'Returning data is not string.');
+    }
+    const jsonData = receiveOne(messages, resData);
+    return check.call(jsonData);
+  }
+
+  requestDevice() {
+    // eslint-disable-next-line prefer-promise-reject-errors
+    return Promise.reject();
+  }
+
+  stop() {
+    this.stopped = true;
+  }
+
+  cancel() {
+    this.Log.debug('canceled');
+  }
+}

package/tsconfig.json

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