@onekeyfe/hd-transport 0.0.1

package/src/types/transport.ts

@@ -0,0 +1,51 @@
+export type OneKeyUsbDeviceInfo = {
+  path: string;
+};
+
+export type OneKeyDeviceInfoWithSession = OneKeyUsbDeviceInfo & {
+  session?: string | null;
+  debugSession?: string | null;
+  debug: boolean;
+};
+
+export type OneKeyMobileDeviceInfo = {
+  id: string;
+  name: string | null;
+};
+
+export type OneKeyDeviceInfo = OneKeyDeviceInfoWithSession & OneKeyMobileDeviceInfo;
+
+export type AcquireInput = {
+  path?: string;
+  previous?: string | null;
+  uuid?: string;
+};
+
+export type MessageFromOneKey = { type: string; message: Record<string, any> };
+
+export type Transport = {
+  enumerate(): Promise<Array<OneKeyDeviceInfo>>;
+  listen(old?: Array<OneKeyDeviceInfo>): Promise<Array<OneKeyDeviceInfo>>;
+  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<MessageFromOneKey>;
+  post(session: string, name: string, data: Record<string, any>): Promise<void>;
+  read(session: string): Promise<MessageFromOneKey>;
+
+  // resolves when the transport can be used; rejects when it cannot
+  init(): Promise<string>;
+  stop(): void;
+
+  configured: boolean;
+  version: string;
+  name: string;
+  activeName?: string;
+
+  // webusb has a different model, where you have to
+  // request device connection
+  requestDevice: () => Promise<void>;
+  requestNeeded: boolean;
+
+  isOutdated: boolean;
+};

package/src/utils/highlevel-checks.ts

@@ -0,0 +1,88 @@
+// input checks for high-level transports
+
+import type { OneKeyDeviceInfoWithSession, MessageFromOneKey } 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<OneKeyDeviceInfoWithSession> {
+  if (typeof res !== 'object') {
+    throw new Error(ERROR);
+  }
+  if (!(res instanceof Array)) {
+    throw new Error(ERROR);
+  }
+  return res.map((o: any): OneKeyDeviceInfoWithSession => {
+    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): MessageFromOneKey {
+  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/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,7 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+  },
+  "include": ["./src"]
+}