refactor: session integration

.changeset/short-ghosts-fetch.md

@@ -0,0 +1,5 @@
+---
+'@cypherock/sdk-core': patch
+---
+
+added inheritance session management

packages/app-inheritance/src/app.ts

@@ -36,6 +36,14 @@ export class InheritanceApp {
     return this.sdk.runOperation(() => operations.authWallet(this.sdk, params));
   }
 
+  public async startSession() {
+    return this.sdk.runOperation(() => this.sdk.startSession());
+  }
+
+  public async closeSession() {
+    return this.sdk.runOperation(() => this.sdk.closeSession());
+  }
+
   public async destroy() {
     return this.sdk.destroy();
   }

packages/core/jest.config.js

@@ -10,7 +10,7 @@ module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   rootDir: '.',
-  testPathIgnorePatterns: ['/node_modules/', '/__fixtures__/', '/dist/'],
+  testPathIgnorePatterns: ['/node_modules/', '/__fixtures__/', '/__helpers__/', '/dist/'],
   testMatch: [
     '**/tests/**/*.[jt]s?(x)',
     '**/__tests__/**/*.[jt]s?(x)',

packages/core/package.json

@@ -33,6 +33,7 @@
   "dependencies": {
     "@cypherock/sdk-interfaces": "workspace:^0.0.15",
     "@cypherock/sdk-utils": "workspace:^0.0.18",
+    "axios": "^1.3.4",
     "compare-versions": "6.0.0-rc.1",
     "protobufjs": "^7.2.2",
     "uuid": "^9.0.0"

packages/core/src/__mocks__/commands.ts

@@ -0,0 +1,54 @@
+import { IDeviceConnection } from '@cypherock/sdk-interfaces';
+import { jest } from '@jest/globals';
+import { Status } from '../encoders/types';
+import { PacketVersion } from '../utils';
+
+type SendCommandType = (params: {
+  connection: IDeviceConnection;
+  rawData?: string;
+  protoData?: string;
+  version: PacketVersion;
+  sequenceNumber: number;
+  maxTries?: number;
+  timeout?: number;
+}) => Promise<void>;
+
+type WaitForResultType = (params: {
+  connection: IDeviceConnection;
+  sequenceNumber: number;
+  appletId: number;
+  onStatus?: (status: Status) => void;
+  version: PacketVersion;
+  options?: { interval?: number; timeout?: number; maxTries?: number };
+  allowCoreData?: boolean;
+}) => Promise<Uint8Array>;
+
+export const sendCommand: jest.Mock<SendCommandType> =
+  jest.fn<SendCommandType>();
+
+export const waitForResult: jest.Mock<WaitForResultType> =
+  jest.fn<WaitForResultType>();
+
+jest.mock('../operations/helpers/sendCommand', () => {
+  const originalModule: any = jest.requireActual(
+    '../operations/helpers/sendCommand',
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    sendCommand,
+  };
+});
+
+jest.mock('../operations/proto/waitForResult', () => {
+  const originalModule: any = jest.requireActual(
+    '../operations/proto/waitForResult',
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    waitForResult,
+  };
+});

packages/core/src/__mocks__/services.ts

@@ -0,0 +1,26 @@
+import { jest } from '@jest/globals';
+import {
+  IInitiateServerSessionParams,
+  IInitiateServerSessionResult,
+} from '../services/types';
+
+type InitiateServerSessionType = (
+  params: IInitiateServerSessionParams,
+) => Promise<IInitiateServerSessionResult>;
+type StartServerSessionType = (params: { sessionId: string }) => Promise<void>;
+
+export const initiateServerSession: jest.Mock<InitiateServerSessionType> =
+  jest.fn<InitiateServerSessionType>();
+export const startServerSession: jest.Mock<StartServerSessionType> =
+  jest.fn<StartServerSessionType>();
+
+jest.mock('../services', () => {
+  const originalModule: any = jest.requireActual('../services');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    initiateServerSession,
+    startServerSession,
+  };
+});

packages/core/src/commands/closeSession.ts

@@ -0,0 +1,97 @@
+import {
+  DeviceAppError,
+  DeviceAppErrorType,
+  IDeviceConnection,
+} from '@cypherock/sdk-interfaces';
+import { assert, uint8ArrayToHex } from '@cypherock/sdk-utils';
+import { DeepPartial, Msg } from '../encoders/proto/generated/core';
+import { SessionCloseResponse } from '../encoders/proto/generated/session';
+import { ISessionCloseResponse } from '../encoders/proto/generated/types';
+import { Status } from '../encoders/types';
+import { sendCommand } from '../operations/helpers';
+import { waitForResult } from '../operations/proto';
+import {
+  assertOrThrowInvalidResult,
+  PacketVersionMap,
+  parseCommonError,
+} from '../utils';
+
+export interface ICloseSessionParams {
+  connection: IDeviceConnection;
+  onStatus?: (status: Status) => void;
+  options?: { interval?: number; timeout?: number; maxTries?: number };
+  getSequenceNumber: () => Promise<number>;
+  getNewSequenceNumber: () => Promise<number>;
+}
+
+const sendSessionCommand = async (
+  params: ICloseSessionParams,
+  data: DeepPartial<Msg['sessionClose']>,
+) => {
+  const { maxTries, timeout } = params.options ?? {};
+
+  const msgData = uint8ArrayToHex(
+    Msg.encode(Msg.create({ sessionClose: data })).finish(),
+  );
+
+  await sendCommand({
+    connection: params.connection,
+    protoData: msgData,
+    rawData: '',
+    version: PacketVersionMap.v3,
+    maxTries,
+    sequenceNumber: await params.getNewSequenceNumber(),
+    timeout,
+  });
+};
+
+const waitForSessionResult = async (
+  params: ICloseSessionParams,
+): Promise<ISessionCloseResponse> => {
+  const { connection, onStatus, options } = params;
+
+  const version = PacketVersionMap.v3;
+
+  const result = await waitForResult({
+    connection,
+    appletId: 0,
+    sequenceNumber: await params.getSequenceNumber(),
+    version,
+    allowCoreData: true,
+    onStatus,
+    options,
+  });
+
+  let msg: Msg;
+  try {
+    msg = Msg.decode(result);
+  } catch (error) {
+    throw new DeviceAppError(DeviceAppErrorType.INVALID_MSG_FROM_DEVICE);
+  }
+
+  const response: SessionCloseResponse | undefined = msg.sessionClose?.response;
+
+  assertOrThrowInvalidResult(response);
+
+  if (response.commonError) {
+    parseCommonError(response.commonError);
+  }
+
+  return response;
+};
+
+export const closeSession = async (
+  params: ICloseSessionParams,
+): Promise<void> => {
+  assert(params.connection, 'Invalid connection');
+  assert(params.getNewSequenceNumber, 'Invalid getNewSequenceNumber');
+
+  await sendSessionCommand(params, {
+    request: {
+      clear: {},
+    },
+  });
+
+  const { clear } = await waitForSessionResult(params);
+  assertOrThrowInvalidResult(clear);
+};

packages/core/src/operations/proto/getAppVersions.ts → packages/core/src/commands/getAppVersions.ts

@@ -4,16 +4,17 @@ import {
   IDeviceConnection,
 } from '@cypherock/sdk-interfaces';
 import { assert, uint8ArrayToHex } from '@cypherock/sdk-utils';
-import { Msg, Status } from '../../encoders/proto/generated/core';
-import { IAppVersionResultResponse } from '../../encoders/proto/generated/types';
-import { AppVersionResponse } from '../../encoders/proto/generated/version';
+import { Msg } from '../encoders/proto/generated/core';
+import { IAppVersionResultResponse } from '../encoders/proto/generated/types';
+import { AppVersionResponse } from '../encoders/proto/generated/version';
+import { Status } from '../encoders/types';
+import { sendCommand } from '../operations/helpers';
+import { waitForResult } from '../operations/proto';
 import {
   assertOrThrowInvalidResult,
   PacketVersionMap,
   parseCommonError,
-} from '../../utils';
-import { sendCommand } from '../helpers';
-import { waitForResult } from './waitForResult';
+} from '../utils';
 
 export interface IGetAppVersionsParams {
   connection: IDeviceConnection;
@@ -60,13 +61,17 @@ export const getAppVersions = async ({
     options,
   });
 
-  let response: AppVersionResponse;
+  let msg: Msg;
   try {
-    response = AppVersionResponse.decode(result);
+    msg = Msg.decode(result);
   } catch (error) {
     throw new DeviceAppError(DeviceAppErrorType.INVALID_MSG_FROM_DEVICE);
   }
 
+  const response: AppVersionResponse | undefined = msg.appVersion?.response;
+
+  assertOrThrowInvalidResult(response);
+
   if (response.commonError) {
     parseCommonError(response.commonError);
   }

packages/core/src/commands/index.ts

@@ -0,0 +1,3 @@
+export * from './getAppVersions';
+export * from './startSession';
+export * from './closeSession';

packages/core/src/commands/startSession.ts

@@ -0,0 +1,130 @@
+import {
+  DeviceAppError,
+  DeviceAppErrorType,
+  IDeviceConnection,
+} from '@cypherock/sdk-interfaces';
+import { assert, hexToUint8Array, uint8ArrayToHex } from '@cypherock/sdk-utils';
+import { DeepPartial, Msg } from '../encoders/proto/generated/core';
+import { SessionStartResponse } from '../encoders/proto/generated/session';
+import { ISessionStartResponse } from '../encoders/proto/generated/types';
+import { Status } from '../encoders/types';
+import { sendCommand } from '../operations/helpers';
+import { waitForResult } from '../operations/proto';
+import { initiateServerSession } from '../services';
+import {
+  assertOrThrowInvalidResult,
+  PacketVersionMap,
+  parseCommonError,
+} from '../utils';
+
+export interface IStartSessionParams {
+  connection: IDeviceConnection;
+  onStatus?: (status: Status) => void;
+  options?: { interval?: number; timeout?: number; maxTries?: number };
+  getSequenceNumber: () => Promise<number>;
+  getNewSequenceNumber: () => Promise<number>;
+}
+
+export interface IStartSessionResult {
+  sessionId: string;
+  sessionAge: number;
+}
+
+const sendSessionCommand = async (
+  params: IStartSessionParams,
+  data: DeepPartial<Msg['sessionStart']>,
+) => {
+  const { maxTries, timeout } = params.options ?? {};
+
+  const msgData = uint8ArrayToHex(
+    Msg.encode(Msg.create({ sessionStart: data })).finish(),
+  );
+
+  await sendCommand({
+    connection: params.connection,
+    protoData: msgData,
+    rawData: '',
+    version: PacketVersionMap.v3,
+    maxTries,
+    sequenceNumber: await params.getNewSequenceNumber(),
+    timeout,
+  });
+};
+
+const waitForSessionResult = async (
+  params: IStartSessionParams,
+): Promise<ISessionStartResponse> => {
+  const { connection, onStatus, options } = params;
+
+  const version = PacketVersionMap.v3;
+
+  const result = await waitForResult({
+    connection,
+    appletId: 0,
+    sequenceNumber: await params.getSequenceNumber(),
+    version,
+    allowCoreData: true,
+    onStatus,
+    options,
+  });
+
+  let msg: Msg;
+  try {
+    msg = Msg.decode(result);
+  } catch (error) {
+    throw new DeviceAppError(DeviceAppErrorType.INVALID_MSG_FROM_DEVICE);
+  }
+
+  const response: SessionStartResponse | undefined = msg.sessionStart?.response;
+
+  assertOrThrowInvalidResult(response);
+
+  if (response.commonError) {
+    parseCommonError(response.commonError);
+  }
+
+  return response;
+};
+
+export const startSession = async (
+  params: IStartSessionParams,
+): Promise<IStartSessionResult> => {
+  assert(params.connection, 'Invalid connection');
+  assert(params.getNewSequenceNumber, 'Invalid getNewSequenceNumber');
+
+  await sendSessionCommand(params, {
+    request: {
+      initiate: {},
+    },
+  });
+
+  const { confirmationInitiate } = await waitForSessionResult(params);
+  assertOrThrowInvalidResult(confirmationInitiate);
+
+  const serverInitiateResponse =
+    await initiateServerSession(confirmationInitiate);
+
+  await sendSessionCommand(params, {
+    request: {
+      start: {
+        sessionAge: serverInitiateResponse.sessionAge,
+        sessionRandomPublic: hexToUint8Array(
+          serverInitiateResponse.publicKey ?? '',
+        ),
+        signature: hexToUint8Array(serverInitiateResponse.signature ?? ''),
+        deviceId: confirmationInitiate.deviceId,
+      },
+    },
+  });
+
+  const { confirmationStart } = await waitForSessionResult(params);
+  assertOrThrowInvalidResult(confirmationStart);
+
+  assert(serverInitiateResponse.sessionId, 'Invalid session ID from server');
+  assert(serverInitiateResponse.sessionAge, 'Invalid session age from server');
+
+  return {
+    sessionId: serverInitiateResponse.sessionId,
+    sessionAge: serverInitiateResponse.sessionAge,
+  };
+};