@ukeyfe/hardware-core 1.1.13

package/src/api/alephium/AlephiumGetAddress.ts

@@ -0,0 +1,83 @@
+import { AlephiumGetAddress as HardwareAlephiumGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { 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: 'showOnOneKey', type: 'boolean' },
+        { name: 'includePublicKey', type: 'boolean' },
+        { name: 'group', type: 'number' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        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,50 @@
+import { AlephiumSignMessage as HardwareAlephiumSignMessage } from '@ukeyfe/hardware-transport';
+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';
+
+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,134 @@
+import {
+  type AlephiumSignedTx,
+  type AlephiumSignTx as HardwareAlephiumSignTx,
+  TypedCall,
+} from '@ukeyfe/hardware-transport';
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { 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 { AlgorandGetAddress as HardwareAlgoGetAddress } from '@ukeyfe/hardware-transport';
+
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { 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: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  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,51 @@
+import { AlgorandSignTx as HardwareAlgorandSignTx } from '@ukeyfe/hardware-transport';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SolanaSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+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,87 @@
+import { HardwareErrorCode, HardwareErrorCodeMessage } from '@ukeyfe/hardware-shared';
+import { CoreApi } from '../../types';
+
+import type {
+  AllNetworkAddress,
+  AllNetworkAddressParams,
+  AllNetworkGetAddressParams,
+} from '../../types/api/allNetworkGetAddress';
+import { createUiMessage } from '../../events';
+import { UI_REQUEST } from '../../constants/ui-request';
+import AllNetworkGetAddressBase from './AllNetworkGetAddressBase';
+
+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);
+  }
+}