@onetokenfe/hd-core 1.1.23

package/src/api/PromptWebDeviceAccess.ts

@@ -0,0 +1,77 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { BaseMethod } from './BaseMethod';
+import TransportManager from '../data-manager/TransportManager';
+import { DataManager } from '../data-manager';
+import { DevicePool } from '../device/DevicePool';
+import { LoggerNames, getLogger } from '../utils';
+
+import type { OneTokenDeviceInfo } from '@onetokenfe/hd-transport';
+
+const Log = getLogger(LoggerNames.Method);
+
+export default class PromptWebDeviceAccess extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const { deviceSerialNumberFromUI } = this.payload;
+    await TransportManager.configure();
+    const isWebUsbEnv = DataManager.getSettings('env') === 'webusb';
+    if (!isWebUsbEnv) {
+      return Promise.reject(
+        ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Not webusb environment')
+      );
+    }
+
+    try {
+      let device;
+      let devicesDescriptor;
+
+      // If serial number is provided, skip prompting user
+      if (deviceSerialNumberFromUI) {
+        // Manually construct device descriptor using provided serial number
+        devicesDescriptor = [
+          {
+            path: deviceSerialNumberFromUI,
+            device: { serialNumber: deviceSerialNumberFromUI },
+            debug: true,
+          },
+        ];
+      } else {
+        // Otherwise prompt user to select a device
+        device = await this.connector?.promptDeviceAccess();
+        if (!device) {
+          return await Promise.reject(
+            ERRORS.TypedError(HardwareErrorCode.WebDevicePromptAccessError)
+          );
+        }
+
+        if (isWebUsbEnv) {
+          devicesDescriptor = [
+            {
+              path: (device as USBDevice).serialNumber ?? '',
+              device,
+              debug: true,
+            },
+          ];
+        }
+      }
+      const { deviceList } = await DevicePool.getDevices(
+        devicesDescriptor as unknown as OneTokenDeviceInfo[]
+      );
+      if (deviceList.length > 0) {
+        return { device: deviceList[0].toMessageObject() };
+      }
+      return { device: null };
+    } catch (error) {
+      Log.debug(error);
+      return Promise.reject(
+        ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect')
+      );
+    }
+  }
+}

package/src/api/SearchDevices.ts

@@ -0,0 +1,50 @@
+import { BaseMethod } from './BaseMethod';
+import TransportManager from '../data-manager/TransportManager';
+import { DataManager } from '../data-manager';
+import { getDeviceTypeByBleName } from '../utils';
+import { DevicePool } from '../device/DevicePool';
+
+import type DeviceConnector from '../device/DeviceConnector';
+
+export default class SearchDevices extends BaseMethod {
+  connector?: DeviceConnector;
+
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    await TransportManager.configure();
+    const deviceDiff = await this.connector?.enumerate();
+    const devicesDescriptor = deviceDiff?.descriptors ?? [];
+
+    const env = DataManager.getSettings('env');
+
+    /**
+     * No need to call features during Bluetooth scaning
+     * to avoid device pairing
+     */
+    if (DataManager.isBleConnect(env)) {
+      const devices = [];
+      const seenIds = new Set<string>();
+
+      for (const device of devicesDescriptor) {
+        const lowerId = device.id?.toLowerCase();
+        if (!seenIds.has(lowerId)) {
+          seenIds.add(lowerId);
+          devices.push({
+            ...device,
+            connectId: device.id,
+            deviceType: getDeviceTypeByBleName(device.name ?? ''),
+          });
+        }
+      }
+      return devices;
+    }
+
+    const { deviceList } = await DevicePool.getDevices(devicesDescriptor);
+    return deviceList.map(device => device.toMessageObject());
+  }
+}

package/src/api/alephium/AlephiumGetAddress.ts

@@ -0,0 +1,84 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+
+import type { AlephiumGetAddress as HardwareAlephiumGetAddress } from '@onetokenfe/hd-transport';
+import type { AlephiumAddress, AlephiumGetAddressParams } from '../../types';
+
+export default class AlephiumGetAddress extends BaseMethod<HardwareAlephiumGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: AlephiumGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneToken', type: 'boolean' },
+        { name: 'includePublicKey', type: 'boolean' },
+        { name: 'group', type: 'number' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        include_public_key: batch.includePublicKey ?? false,
+        // When group is 'null', the 'group' parameter will not be sent
+        ...(batch.group !== null && { target_group: batch.group ?? 0 }),
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: AlephiumAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('AlephiumGetAddress', 'AlephiumAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result: AlephiumAddress = {
+        path: serializedPath(param.address_n),
+        address,
+        publicKey: param.include_public_key ? res.message.public_key : undefined,
+        pub: param.include_public_key ? res.message.public_key : undefined,
+        derivedPath: serializedPath(res.message.derived_path),
+      };
+      responses.push(result);
+
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/alephium/AlephiumSignMessage.ts

@@ -0,0 +1,51 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { stripHexPrefix } from '../helpers/hexUtils';
+
+import type { AlephiumSignMessage as HardwareAlephiumSignMessage } from '@onetokenfe/hd-transport';
+
+export default class AlephiumSignMessage extends BaseMethod<HardwareAlephiumSignMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'messageType', type: 'string' },
+    ]);
+
+    const { path, messageHex, messageType } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: stripHexPrefix(messageHex),
+      message_type: Buffer.from(messageType ?? 'alephium', 'utf-8').toString('hex'),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall(
+      'AlephiumSignMessage',
+      'AlephiumMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(response.message);
+  }
+}

package/src/api/alephium/AlephiumSignTransaction.ts

@@ -0,0 +1,135 @@
+import {
+  type AlephiumSignedTx,
+  type AlephiumSignTx as HardwareAlephiumSignTx,
+  TypedCall,
+} from '@onetokenfe/hd-transport';
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import type { AlephiumSignTransactionParams } from '../../types';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+
+export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephiumSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', required: true, type: 'hexString' },
+      { name: 'scriptOpt', type: 'string' },
+    ]);
+
+    const { path } = this.payload as AlephiumSignTransactionParams;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      data_initial_chunk: '',
+      data_length: 0,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  chunkByteSize = 1024;
+
+  processTxRequest = async (
+    typedCall: TypedCall,
+    res:
+      | TypedResponseMessage<'AlephiumSignedTx'>
+      | TypedResponseMessage<'AlephiumTxRequest'>
+      | TypedResponseMessage<'AlephiumBytecodeRequest'>,
+    data: Buffer,
+    scriptOpt?: Buffer,
+    dataOffset = 0
+  ): Promise<AlephiumSignedTx> => {
+    if (res.type === 'AlephiumSignedTx') {
+      return res.message;
+    }
+
+    const { data_length } = res.message;
+
+    let response;
+    if (res.type === 'AlephiumTxRequest') {
+      if (!data_length) {
+        // sign Done
+        return res.message;
+      }
+
+      const payload = data.subarray(dataOffset, dataOffset + data_length);
+      const newOffset = dataOffset + payload.length;
+      const resourceAckParams = {
+        data_chunk: bytesToHex(payload),
+      };
+
+      response = await typedCall(
+        'AlephiumTxAck',
+        ['AlephiumSignedTx', 'AlephiumTxRequest', 'AlephiumBytecodeRequest'],
+        {
+          ...resourceAckParams,
+        }
+      );
+
+      return this.processTxRequest(typedCall, response, data, scriptOpt, newOffset);
+    }
+
+    if (res.type === 'AlephiumBytecodeRequest') {
+      if (!scriptOpt?.length) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'scriptOpt is required');
+      }
+
+      const resourceAckParams = {
+        bytecode_data: bytesToHex(scriptOpt),
+      };
+
+      response = await typedCall(
+        'AlephiumBytecodeAck',
+        ['AlephiumSignedTx', 'AlephiumBytecodeRequest'],
+        {
+          ...resourceAckParams,
+        }
+      );
+
+      return this.processTxRequest(typedCall, response, data, scriptOpt, dataOffset);
+    }
+
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Unknown response type: ${res.type}`);
+  };
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const offset = this.chunkByteSize;
+    const data = Buffer.from(this.payload.rawTx, 'hex');
+    const scriptOpt = this.payload.scriptOpt && Buffer.from(this.payload.scriptOpt, 'hex');
+    this.params = {
+      address_n: this.params.address_n,
+      data_initial_chunk: bytesToHex(data.subarray(0, this.chunkByteSize)),
+      data_length: data.length,
+    };
+
+    const res = await typedCall(
+      'AlephiumSignTx',
+      ['AlephiumSignedTx', 'AlephiumTxRequest', 'AlephiumBytecodeRequest'],
+      {
+        ...this.params,
+      }
+    );
+
+    return this.processTxRequest(typedCall, res, data, scriptOpt, offset);
+  }
+}

package/src/api/algo/AlgoGetAddress.ts

@@ -0,0 +1,73 @@
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+
+import type { AlgorandGetAddress as HardwareAlgoGetAddress } from '@onetokenfe/hd-transport';
+import type { AlgoAddress, AlgoGetAddressParams } from '../../types';
+
+export default class AlgoGetAddress extends BaseMethod<HardwareAlgoGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: AlgoGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: AlgoAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('AlgorandGetAddress', 'AlgorandAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/algo/AlgoSignTransaction.ts

@@ -0,0 +1,52 @@
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+import type { SolanaSignTransactionParams } from '../../types';
+import type { AlgorandSignTx as HardwareAlgorandSignTx } from '@onetokenfe/hd-transport';
+
+export default class AlgoSignTransaction extends BaseMethod<HardwareAlgorandSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx } = this.payload as SolanaSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('AlgorandSignTx', 'AlgorandSignedTx', {
+      ...this.params,
+    });
+
+    const { signature } = res.message;
+
+    return {
+      path: serializedPath(this.params.address_n),
+      signature,
+    };
+  }
+}

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -0,0 +1,88 @@
+import { HardwareErrorCode, HardwareErrorCodeMessage } from '@onetokenfe/hd-shared';
+
+import { createUiMessage } from '../../events';
+import { UI_REQUEST } from '../../constants/ui-request';
+import AllNetworkGetAddressBase from './AllNetworkGetAddressBase';
+
+import type { CoreApi } from '../../types';
+import type {
+  AllNetworkAddress,
+  AllNetworkAddressParams,
+  AllNetworkGetAddressParams,
+} from '../../types/api/allNetworkGetAddress';
+
+type MethodParams = {
+  methodName: keyof CoreApi;
+  params: Parameters<CoreApi[keyof CoreApi]>[0];
+  _originRequestParams: AllNetworkAddressParams;
+  _originalIndex: number;
+};
+
+export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
+  async getAllNetworkAddress(rootFingerprint: number) {
+    const responses: AllNetworkAddress[] = [];
+    const resultMap: Record<string, AllNetworkAddress> = {};
+    const { bundle } = this.payload as AllNetworkGetAddressParams;
+
+    const methodGroups = bundle
+      .map((param, index) =>
+        this.generateMethodName({
+          network: param.network,
+          payload: param,
+          originalIndex: index,
+        })
+      )
+      .reduce((acc, cur) => {
+        if (!acc[cur.methodName]) {
+          acc[cur.methodName] = [];
+        }
+        acc[cur.methodName].push(cur);
+        return acc;
+      }, {} as Record<keyof CoreApi, MethodParams[]>);
+
+    let i = 0;
+    for (const [methodName, params] of Object.entries(methodGroups)) {
+      const methodParams = {
+        bundle: params.map(param => ({
+          ...param.params,
+        })),
+      };
+
+      if (this.abortController?.signal.aborted) {
+        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+      }
+      // call method
+      const response = await this.callMethod(
+        methodName as keyof CoreApi,
+        methodParams,
+        rootFingerprint
+      );
+
+      if (this.abortController?.signal.aborted) {
+        throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
+      }
+
+      for (let i = 0; i < params.length; i++) {
+        const { _originRequestParams, _originalIndex } = params[i];
+        const responseKey = `${_originalIndex}`;
+        resultMap[responseKey] = {
+          ..._originRequestParams,
+          ...response[i],
+        };
+      }
+
+      if (this.payload?.bundle?.length > 1) {
+        const progress = Math.round(((i + 1) / this.payload.bundle.length) * 100);
+        this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress }));
+      }
+      i++;
+    }
+
+    for (let i = 0; i < bundle.length; i++) {
+      responses.push(resultMap[i]);
+    }
+
+    this.abortController = null;
+    return Promise.resolve(responses);
+  }
+}