@ukeyfe/hardware-core 1.1.13

package/src/api/aptos/AptosGetAddress.ts

@@ -0,0 +1,128 @@
+import { AptosGetAddress as HardwareAptosGetAddress } from '@ukeyfe/hardware-transport';
+
+import { sha3_256 as sha3Hash } from '@noble/hashes/sha3';
+import { bytesToHex } from '@noble/hashes/utils';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { AptosAddress, AptosGetAddressParams } from '../../types';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { hexToBytes } from '../helpers/hexUtils';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class AptosGetAddress extends BaseMethod<HardwareAptosGetAddress[]> {
+  hasBundle = false;
+
+  shouldConfirm = 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] };
+
+    this.shouldConfirm =
+      this.payload.showOnOneKey ||
+      this.payload.bundle?.some((i: AptosGetAddressParams) => !!i.showOnOneKey);
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: AptosGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  publicKeyToAddress(publicKey: string) {
+    const hash = sha3Hash.create();
+    hash.update(hexToBytes(publicKey));
+    hash.update('\x00');
+    return `0x${bytesToHex(hash.digest())}`;
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    const supportsBatchPublicKey = supportBatchPublicKey(this.device?.features);
+    let responses: AptosAddress[] = [];
+    if (supportsBatchPublicKey) {
+      const publicKeyRes = await batchGetPublickeys(this.device, this.params, 'ed25519', 637);
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const publicKey = publicKeyRes.public_keys[i];
+        let address: string;
+
+        if (this.shouldConfirm) {
+          const addressRes = await this.device.commands.typedCall(
+            'AptosGetAddress',
+            'AptosAddress',
+            param
+          );
+          address = addressRes.message.address?.toLowerCase() ?? '';
+        } else {
+          address = this.publicKeyToAddress(publicKey);
+        }
+
+        const result: AptosAddress = {
+          path: serializedPath(param.address_n),
+          address,
+          publicKey,
+          pub: publicKey,
+        };
+
+        if (this.shouldConfirm) {
+          this.postPreviousAddressMessage(result);
+        }
+
+        responses.push(result);
+      }
+    } else {
+      responses = await Promise.all(
+        this.params.map(async param => {
+          const res = await this.device.commands.typedCall(
+            'AptosGetAddress',
+            'AptosAddress',
+            param
+          );
+          const result = {
+            path: serializedPath(param.address_n),
+            address: res.message.address?.toLowerCase() ?? '',
+          };
+          if (this.shouldConfirm) {
+            this.postPreviousAddressMessage(result);
+          }
+          return result;
+        })
+      );
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/aptos/AptosGetPublicKey.ts

@@ -0,0 +1,63 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { AptosGetAddressParams, AptosPublicKey } from '../../types';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class AptosGetPublicKey extends BaseMethod<any> {
+  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: AptosGetAddressParams) => {
+      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 res = await batchGetPublickeys(this.device, this.params, 'ed25519', 637);
+
+    const responses: AptosPublicKey[] = res.public_keys.map((publicKey: string, index: number) => ({
+      path: serializedPath((this.params as unknown as any[])[index].address_n),
+      pub: publicKey,
+      publicKey,
+    }));
+
+    validateResult(responses, ['pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/aptos/AptosSignInMessage.ts

@@ -0,0 +1,54 @@
+import { AptosSignSIWAMessage } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { AptosSignInMessageParams, AptosSignInMessageSignature } from '../../types';
+
+export default class AptosSignInMessage extends BaseMethod<AptosSignSIWAMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'payload', type: 'string', required: true },
+    ]);
+
+    const { path, payload } = this.payload as AptosSignInMessageParams;
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      siwa_payload: payload,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.16.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'AptosSignSIWAMessage',
+      'AptosMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    const { address, signature } = res.message;
+
+    return Promise.resolve<AptosSignInMessageSignature>({
+      path: serializedPath(this.params.address_n),
+      address,
+      signature,
+    });
+  }
+}

package/src/api/aptos/AptosSignMessage.ts

@@ -0,0 +1,78 @@
+import { AptosSignMessage as HardwareAptosSignMessage } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { AptosMessageSignature, AptosSignMessageParams } from '../../types';
+
+export default class AptosSignMessage extends BaseMethod<HardwareAptosSignMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'payload', type: 'object', required: true },
+    ]);
+
+    const { path, payload } = this.payload as AptosSignMessageParams;
+    const addressN = validatePath(path, 3);
+
+    validateParams(payload, [
+      { name: 'address', type: 'string' },
+      { name: 'chainId', type: 'string' },
+      { name: 'application', type: 'string' },
+      { name: 'nonce', type: 'string', required: true },
+      { name: 'message', type: 'string', required: true },
+    ]);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      payload: {
+        address: payload.address,
+        chain_id: payload.chainId,
+        application: payload.application,
+        nonce: payload.nonce,
+        message: payload.message,
+      },
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  async run() {
+    let fullMessage = 'APTOS\n';
+    if (this.params.payload.address) {
+      fullMessage += `address: ${this.params.payload.address}\n`;
+    }
+    if (this.params.payload.application) {
+      fullMessage += `application: ${this.params.payload.application}\n`;
+    }
+    if (this.params.payload.chain_id) {
+      fullMessage += `chainId: ${this.params.payload.chain_id}\n`;
+    }
+    fullMessage += `message: ${this.params.payload.message}\n`;
+    fullMessage += `nonce: ${this.params.payload.nonce}`;
+
+    const res = await this.device.commands.typedCall('AptosSignMessage', 'AptosMessageSignature', {
+      ...this.params,
+    });
+
+    const { address, signature } = res.message;
+
+    return Promise.resolve<AptosMessageSignature>({
+      path: serializedPath(this.params.address_n),
+      address,
+      signature,
+      fullMessage,
+    });
+  }
+}

package/src/api/aptos/AptosSignTransaction.ts

@@ -0,0 +1,71 @@
+import { AptosSignTx as HardwareAptosSignTx } 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 { formatAnyHex } from '../helpers/hexUtils';
+
+export default class AptosSignTransaction extends BaseMethod<HardwareAptosSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+      { name: 'transactionType', type: 'number', required: false },
+    ]);
+
+    const { path, rawTx, transactionType } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+      tx_type: transactionType,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.6.0',
+      },
+    };
+  }
+
+  getWithDataVersionRange() {
+    return {
+      pro: {
+        min: '4.14.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+      classic: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  checkWithDataError() {
+    const { transactionType } = this.payload;
+    this.checkFeatureVersionLimit(
+      () => transactionType === 1,
+      () => this.getWithDataVersionRange()
+    );
+  }
+
+  async run() {
+    this.checkWithDataError();
+
+    const res = await this.device.commands.typedCall('AptosSignTx', 'AptosSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/benfen/BenfenGetAddress.ts

@@ -0,0 +1,122 @@
+import { BenfenGetAddress as HardwareBenfenGetAddress } from '@ukeyfe/hardware-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { hex2BfcAddress, publicKeyToAddress } from './normalize';
+import { BenfenAddress, BenfenGetAddressParams } from '../../types';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddress[]> {
+  hasBundle = false;
+
+  shouldConfirm = false;
+
+  strictCheckDeviceSupport = true;
+
+  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] };
+
+    this.shouldConfirm =
+      this.payload.showOnOneKey ||
+      this.payload.bundle?.some((i: BenfenGetAddressParams) => !!i.showOnOneKey);
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: BenfenGetAddressParams) => {
+      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 {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  async run() {
+    const supportsBatchPublicKey = supportBatchPublicKey(this.device?.features);
+    let responses: BenfenAddress[] = [];
+
+    if (supportsBatchPublicKey) {
+      const publicKeyRes = await batchGetPublickeys(this.device, this.params, 'ed25519', 728);
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const publicKey = publicKeyRes.public_keys[i];
+        let address: string;
+
+        if (this.shouldConfirm) {
+          const addressRes = await this.device.commands.typedCall(
+            'BenfenGetAddress',
+            'BenfenAddress',
+            param
+          );
+          address = addressRes.message.address;
+        } else {
+          address = publicKeyToAddress(publicKey);
+        }
+
+        const result = {
+          path: serializedPath(param.address_n),
+          // 将 address 转为BFC格式
+          address: hex2BfcAddress(address),
+          pub: publicKey,
+        };
+
+        if (this.shouldConfirm) {
+          this.postPreviousAddressMessage(result);
+        }
+
+        responses.push(result);
+      }
+    } else {
+      responses = await Promise.all(
+        this.params.map(async param => {
+          const res = await this.device.commands.typedCall(
+            'BenfenGetAddress',
+            'BenfenAddress',
+            param
+          );
+          const result = {
+            path: serializedPath(param.address_n),
+            address: hex2BfcAddress(res.message.address),
+          };
+          if (this.shouldConfirm) {
+            this.postPreviousAddressMessage(result);
+          }
+          return result;
+        })
+      );
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/benfen/BenfenGetPublicKey.ts

@@ -0,0 +1,67 @@
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BenfenPublicKey, BenfenGetPublicKeyParams } from '../../types';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class BenfenGetPublicKey extends BaseMethod<any> {
+  hasBundle = false;
+
+  strictCheckDeviceSupport = true;
+
+  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] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: BenfenGetPublicKeyParams) => {
+      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 {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await batchGetPublickeys(this.device, this.params, 'ed25519', 728);
+
+    const responses: BenfenPublicKey[] = res.public_keys.map(
+      (publicKey: string, index: number) => ({
+        path: serializedPath((this.params as any[])[index].address_n),
+        pub: publicKey,
+      })
+    );
+
+    validateResult(responses, ['pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/benfen/BenfenSignMessage.ts

@@ -0,0 +1,49 @@
+import { BenfenSignMessage as HardwareBenfenSignMessage } 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 BenfenSignMessage extends BaseMethod<HardwareBenfenSignMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+    ]);
+
+    const { path, messageHex } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      message: stripHexPrefix(messageHex),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall(
+      'BenfenSignMessage',
+      'BenfenMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(response.message);
+  }
+}