@ukeyfe/hardware-core 1.1.13

package/src/api/solana/SolSignMessage.ts

@@ -0,0 +1,60 @@
+import { SolanaSignUnsafeMessage as HardwareSolSignUnsafeMessage } 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 SolSignMessage extends BaseMethod<HardwareSolSignUnsafeMessage> {
+  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 },
+    ]);
+
+    const { path, messageHex } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: stripHexPrefix(messageHex),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.12.0',
+      },
+      touch: {
+        min: '4.10.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+      model_mini: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall(
+      'SolanaSignUnsafeMessage',
+      'SolanaMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve({
+      signature: response.message.signature,
+      pub: response.message.public_key,
+    });
+  }
+}

package/src/api/solana/SolSignOffchainMessage.ts

@@ -0,0 +1,60 @@
+import { SolanaSignOffChainMessage as HardwareSolSignOffChainMessage } 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 SolSignOffchainMessage extends BaseMethod<HardwareSolSignOffChainMessage> {
+  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: 'messageVersion', type: 'number', required: false },
+      { name: 'messageFormat', type: 'number', required: false },
+      { name: 'applicationDomainHex', type: 'hexString', required: false },
+    ]);
+
+    const { path, messageHex, messageVersion, messageFormat, applicationDomainHex } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: stripHexPrefix(messageHex),
+      message_version: messageVersion ?? undefined,
+      message_format: messageFormat ?? undefined,
+      application_domain: applicationDomainHex ?? undefined,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall(
+      'SolanaSignOffChainMessage',
+      'SolanaMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve({
+      signature: response.message.signature,
+      pub: response.message.public_key,
+    });
+  }
+}

package/src/api/solana/SolSignTransaction.ts

@@ -0,0 +1,105 @@
+import { SolanaSignTx as HardwareSolanaSignTx } 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 { SolanaSignedTx, SolanaSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[]> {
+  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: SolanaSignTransactionParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'rawTx', type: 'hexString', required: true },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        raw_tx: formatAnyHex(batch.rawTx),
+      });
+    });
+  }
+
+  getVersionRange() {
+    if (this.existsVersionedTx()) {
+      return {
+        model_mini: {
+          min: '3.1.0',
+        },
+        model_touch: {
+          min: '4.3.0',
+        },
+      };
+    }
+
+    return {
+      classic: {
+        min: '2.1.9',
+      },
+      mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
+  isVersionedTx(hexString: string) {
+    if (hexString.length === 0) return false;
+    try {
+      const cleanHexString = hexString.startsWith('0x') ? hexString.slice(2) : hexString;
+      const binary = parseInt(cleanHexString[0], 16).toString(2);
+
+      // Check highest bit
+      return binary[0] === '1';
+    } catch {
+      return false;
+    }
+  }
+
+  existsVersionedTx() {
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+      const { raw_tx } = param;
+      if (this.isVersionedTx(raw_tx)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async run() {
+    const responses: SolanaSignedTx[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('SolanaSignTx', 'SolanaSignedTx', {
+        ...param,
+      });
+
+      const { signature } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        signature,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/starcoin/StarcoinGetAddress.ts

@@ -0,0 +1,68 @@
+import { StarcoinGetAddress as HardwareStarcoinGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath, serializedPath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { StarcoinAddress, StarcoinGetAddressParams } from '../../types/api/starcoinGetAddress';
+
+export default class StarcoinGetAddress extends BaseMethod<HardwareStarcoinGetAddress[]> {
+  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: StarcoinGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: StarcoinAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('StarcoinGetAddress', 'StarcoinAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        ...res.message,
+      });
+
+      this.postPreviousAddressMessage({
+        path,
+        address: res.message.address,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/starcoin/StarcoinGetPublicKey.ts

@@ -0,0 +1,69 @@
+import { StarcoinGetPublicKey as HardwareStarcoinGetPublicKey } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath, serializedPath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import {
+  StarcoinPublicKey,
+  StarcoinGetPublicKeyParams,
+} from '../../types/api/starcoinGetPublicKey';
+
+export default class StarcoinGetPublicKey extends BaseMethod<HardwareStarcoinGetPublicKey[]> {
+  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: StarcoinGetPublicKeyParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: StarcoinPublicKey[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall(
+        'StarcoinGetPublicKey',
+        'StarcoinPublicKey',
+        {
+          ...param,
+        }
+      );
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ...res.message,
+      });
+    }
+
+    validateResult(responses, ['public_key'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/starcoin/StarcoinSignMessage.ts

@@ -0,0 +1,41 @@
+import { StarcoinSignMessage as HardwareStarcoinSignMessage } 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 StarcoinSignMessage extends BaseMethod<HardwareStarcoinSignMessage> {
+  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 },
+    ]);
+
+    const { path, messageHex } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: formatAnyHex(messageHex),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'StarcoinSignMessage',
+      'StarcoinMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/starcoin/StarcoinSignTransaction.ts

@@ -0,0 +1,37 @@
+import { StarcoinSignTx } 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 StarcoinSignTransaction extends BaseMethod<StarcoinSignTx> {
+  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 },
+    ]);
+
+    const { path, rawTx } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('StarcoinSignTx', 'StarcoinSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/starcoin/StarcoinVerifyMessage.ts

@@ -0,0 +1,34 @@
+import { StarcoinVerifyMessage as HardwareStarcoinVerifyMessage } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class EVMSignMessage extends BaseMethod<HardwareStarcoinVerifyMessage> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'publicKey', type: 'string', required: true },
+      { name: 'messageHex', type: 'hexString', required: true },
+      { name: 'signature', type: 'hexString', required: true },
+    ]);
+
+    const { publicKey, messageHex, signature } = formatAnyHex(this.payload);
+
+    this.params = {
+      public_key: publicKey,
+      message: messageHex,
+      signature,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('StarcoinVerifyMessage', 'Success', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/stellar/StellarGetAddress.ts

@@ -0,0 +1,67 @@
+import { StellarGetAddress as HardwareStellarGetAddress } 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 { StellarGetAddressParams, StellarAddress } from '../../types';
+
+export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddress[]> {
+  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: StellarGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: StellarAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('StellarGetAddress', 'StellarAddress', {
+        ...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]);
+  }
+}