@ukeyfe/hardware-transport 1.1.13

package/src/types/transport.ts

@@ -0,0 +1,71 @@
+import type EventEmitter from 'events';
+
+export type UKeyUsbDeviceInfo = {
+  path: string;
+};
+
+export type UKeyDeviceInfoWithSession = UKeyUsbDeviceInfo & {
+  session?: string | null;
+  debugSession?: string | null;
+  debug: boolean;
+};
+
+export type UKeyMobileDeviceInfo = {
+  id: string;
+  name: string | null;
+};
+
+export type UKeyDeviceInfo = UKeyDeviceInfoWithSession & UKeyMobileDeviceInfo;
+
+export type AcquireInput = {
+  path?: string;
+  previous?: string | null;
+  uuid?: string;
+  forceCleanRunPromise?: boolean;
+};
+
+export type MessageFromUKey = { type: string; message: Record<string, any> };
+
+type ITransportInitFn = (
+  logger?: any,
+  emitter?: EventEmitter,
+  plugin?: LowlevelTransportSharedPlugin
+) => Promise<string>;
+
+export type Transport = {
+  enumerate(): Promise<Array<UKeyDeviceInfo>>;
+  listen(old?: Array<UKeyDeviceInfo>): Promise<Array<UKeyDeviceInfo>>;
+  acquire(input: AcquireInput): Promise<string>;
+  release(session: string, onclose: boolean): Promise<void>;
+  configure(signedData: JSON | string): Promise<void>;
+  call(session: string, name: string, data: Record<string, any>): Promise<MessageFromUKey>;
+  post(session: string, name: string, data: Record<string, any>): Promise<void>;
+  read(session: string): Promise<MessageFromUKey>;
+  cancel(): Promise<void>;
+
+  // web-usb, web-bluetooth request device
+  promptDeviceAccess?: () => Promise<USBDevice | BluetoothDevice | null>;
+
+  // resolves when the transport can be used; rejects when it cannot
+  init: ITransportInitFn;
+  stop(): void;
+
+  configured: boolean;
+  version: string;
+  name: string;
+  activeName?: string;
+
+  isOutdated: boolean;
+};
+
+export type LowLevelDevice = { id: string; name: string };
+export type LowlevelTransportSharedPlugin = {
+  enumerate: () => Promise<LowLevelDevice[]>;
+  send: (uuid: string, data: string) => Promise<void>;
+  receive: () => Promise<string>;
+  connect: (uuid: string) => Promise<void>;
+  disconnect: (uuid: string) => Promise<void>;
+
+  init: () => Promise<void>;
+  version: string;
+};

package/src/utils/highlevel-checks.ts

@@ -0,0 +1,88 @@
+// input checks for high-level transports
+
+import type { UKeyDeviceInfoWithSession, MessageFromUKey } from '../types';
+
+const ERROR = 'Wrong result type.';
+
+export function info(res: any) {
+  if (typeof res !== 'object' || res == null) {
+    throw new Error('Wrong result type.');
+  }
+  const { version } = res;
+  if (typeof version !== 'string') {
+    throw new Error(ERROR);
+  }
+  const configured = !!res.configured;
+  return { version, configured };
+}
+
+export function version(version: any) {
+  if (typeof version !== 'string') {
+    throw new Error(ERROR);
+  }
+  return version.trim();
+}
+
+function convertSession(r: any) {
+  if (r == null) {
+    return null;
+  }
+  if (typeof r !== 'string') {
+    throw new Error(ERROR);
+  }
+  return r;
+}
+
+export function devices(res: any): Array<UKeyDeviceInfoWithSession> {
+  if (typeof res !== 'object') {
+    throw new Error(ERROR);
+  }
+  if (!(res instanceof Array)) {
+    throw new Error(ERROR);
+  }
+  return res.map((o: any): UKeyDeviceInfoWithSession => {
+    if (typeof o !== 'object' || o == null) {
+      throw new Error(ERROR);
+    }
+    const { path } = o;
+    if (typeof path !== 'string') {
+      throw new Error(ERROR);
+    }
+    const pathS = path.toString();
+    return {
+      path: pathS,
+      session: convertSession(o.session),
+      debugSession: convertSession(o.debugSession),
+      // @ts-ignore
+      product: o.product,
+      vendor: o.vendor,
+      debug: !!o.debug,
+    };
+  });
+}
+
+export function acquire(res: any) {
+  if (typeof res !== 'object' || res == null) {
+    throw new Error(ERROR);
+  }
+  const { session } = res;
+  if (typeof session !== 'string' && typeof session !== 'number') {
+    throw new Error(ERROR);
+  }
+  return session.toString();
+}
+
+export function call(res: any): MessageFromUKey {
+  if (typeof res !== 'object' || res == null) {
+    throw new Error(ERROR);
+  }
+  const { type } = res;
+  if (typeof type !== 'string') {
+    throw new Error(ERROR);
+  }
+  const { message } = res;
+  if (typeof message !== 'object' || message == null) {
+    throw new Error(ERROR);
+  }
+  return { type, message };
+}

package/src/utils/logBlockCommand.ts

@@ -0,0 +1 @@
+export const LogBlockCommand = new Set(['PassphraseAck', 'PinMatrixAck']);

package/src/utils/protobuf.ts

@@ -0,0 +1,24 @@
+const primitiveTypes = [
+  'bool',
+  'string',
+  'bytes',
+  'int32',
+  'int64',
+  'uint32',
+  'uint64',
+  'sint32',
+  'sint64',
+  'fixed32',
+  'fixed64',
+  'sfixed32',
+  'sfixed64',
+  'double',
+  'float',
+];
+
+/**
+ * Determines whether given field is "primitive"
+ * bool, strings, uint32 => true
+ * HDNodeType => false
+ */
+export const isPrimitiveField = (field: any) => primitiveTypes.includes(field);

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "types": [
+      "w3c-web-usb",
+      "web-bluetooth"
+    ]
+  },
+  "include": ["./src"]
+}