@ukeyfe/hardware-core 1.1.13

package/src/api/stellar/StellarSignTransaction.ts

@@ -0,0 +1,218 @@
+import {
+  StellarMemoType,
+  StellarSignedTx,
+  StellarSignTx as HardwareStellarSignTx,
+} from '@ukeyfe/hardware-transport';
+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 { StellarOperation, StellarSignTransactionParams } from '../../types';
+
+export default class StellarSignTransaction extends BaseMethod<HardwareStellarSignTx> {
+  operations: any[] = [];
+
+  parseOperation = (op: StellarOperation) => {
+    switch (op.type) {
+      case 'createAccount':
+        validateParams(op, [
+          { name: 'destination', type: 'string', required: true },
+          { name: 'startingBalance', type: 'bigNumber', required: true },
+        ]);
+        return {
+          type: 'StellarCreateAccountOp',
+          source_account: op.source,
+          new_account: op.destination,
+          starting_balance: op.startingBalance,
+        };
+
+      case 'payment':
+        validateParams(op, [
+          { name: 'destination', type: 'string', required: true },
+          { name: 'amount', type: 'bigNumber', required: true },
+          { name: 'asset', required: true },
+        ]);
+        return {
+          type: 'StellarPaymentOp',
+          source_account: op.source,
+          destination_account: op.destination,
+          asset: op.asset,
+          amount: op.amount,
+        };
+
+      case 'pathPayment':
+        validateParams(op, [{ name: 'destAmount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarPathPaymentOp',
+          source_account: op.source,
+          send_asset: op.sendAsset,
+          send_max: op.sendMax,
+          destination_account: op.destination,
+          destination_asset: op.destAsset,
+          destination_amount: op.destAmount,
+          paths: op.path,
+        };
+
+      case 'createPassiveOffer':
+        validateParams(op, [{ name: 'amount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarCreatePassiveOfferOp',
+          source_account: op.source,
+          buying_asset: op.buying,
+          selling_asset: op.selling,
+          amount: op.amount,
+          price_n: op.price.n,
+          price_d: op.price.d,
+        };
+
+      case 'manageOffer':
+        validateParams(op, [{ name: 'amount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarManageOfferOp',
+          source_account: op.source,
+          buying_asset: op.buying,
+          selling_asset: op.selling,
+          amount: op.amount,
+          offer_id: op.offerId,
+          price_n: op.price.n,
+          price_d: op.price.d,
+        };
+
+      case 'setOptions': {
+        const signer = op.signer
+          ? {
+              signer_type: op.signer.type,
+              signer_key: op.signer.key,
+              signer_weight: op.signer.weight,
+            }
+          : undefined;
+        return {
+          type: 'StellarSetOptionsOp',
+          source_account: op.source,
+          clear_flags: op.clearFlags,
+          set_flags: op.setFlags,
+          master_weight: op.masterWeight,
+          low_threshold: op.lowThreshold,
+          medium_threshold: op.medThreshold,
+          high_threshold: op.highThreshold,
+          home_domain: op.homeDomain,
+          inflation_destination_account: op.inflationDest,
+          ...signer,
+        };
+      }
+
+      case 'changeTrust':
+        validateParams(op, [{ name: 'limit', type: 'bigNumber' }]);
+        return {
+          type: 'StellarChangeTrustOp',
+          source_account: op.source,
+          asset: op.line,
+          limit: op.limit,
+        };
+
+      case 'allowTrust':
+        return {
+          type: 'StellarAllowTrustOp',
+          source_account: op.source,
+          trusted_account: op.trustor,
+          asset_type: op.assetType,
+          asset_code: op.assetCode,
+          is_authorized: op.authorize ? 1 : 0,
+        };
+
+      case 'accountMerge':
+        return {
+          type: 'StellarAccountMergeOp',
+          source_account: op.source,
+          destination_account: op.destination,
+        };
+
+      case 'manageData':
+        return {
+          type: 'StellarManageDataOp',
+          source_account: op.source,
+          key: op.name,
+          value: op.value,
+        };
+
+      case 'bumpSequence':
+        return {
+          type: 'StellarBumpSequenceOp',
+          source_account: op.source,
+          bump_to: op.bumpTo,
+        };
+      default:
+        return {};
+    }
+  };
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'networkPassphrase', type: 'string', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+
+    const { transaction, networkPassphrase } = this.payload as StellarSignTransactionParams;
+    if (!transaction.timebounds) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'timebounds is required'
+      );
+    }
+
+    // init params
+    const addressN = validatePath(this.payload.path, 3);
+
+    this.params = {
+      address_n: addressN,
+      network_passphrase: networkPassphrase,
+      source_account: transaction.source,
+      fee: transaction.fee,
+      sequence_number: transaction.sequence,
+      num_operations: transaction.operations.length,
+      memo_type: StellarMemoType.NONE,
+      timebounds_start: transaction.timebounds.minTime,
+      timebounds_end: transaction.timebounds.maxTime,
+    };
+
+    if (transaction.memo) {
+      this.params.memo_type = transaction.memo.type;
+      this.params.memo_text = transaction.memo.text;
+      this.params.memo_id = transaction.memo.id;
+      this.params.memo_hash = transaction.memo.hash;
+    }
+
+    transaction.operations.forEach(op => {
+      const transformed = this.parseOperation(op);
+      if (transformed) {
+        this.operations.push(transformed);
+      }
+    });
+  }
+
+  processTxRequest = async (operations: any, index: number): Promise<StellarSignedTx> => {
+    const isLastOp = index + 1 >= operations.length;
+    const { type, ...op } = operations[index];
+
+    if (isLastOp) {
+      const response = await this.device.commands.typedCall(type, 'StellarSignedTx', op);
+      return response.message;
+    }
+
+    await this.device.commands.typedCall(type, 'StellarTxOpRequest', op);
+
+    return this.processTxRequest(operations, index + 1);
+  };
+
+  async run() {
+    await this.device.commands.typedCall('StellarSignTx', 'StellarTxOpRequest', { ...this.params });
+
+    return this.processTxRequest(this.operations, 0);
+  }
+}

package/src/api/sui/SuiGetAddress.ts

@@ -0,0 +1,117 @@
+import { SuiGetAddress as HardwareSuiGetAddress } 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 { SuiAddress, SuiGetAddressParams } from '../../types';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { publicKeyToAddress } from './normalize';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+export default class SuiGetAddress extends BaseMethod<HardwareSuiGetAddress[]> {
+  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: SuiGetAddressParams) => !!i.showOnOneKey);
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: SuiGetAddressParams) => {
+      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: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  async run() {
+    const supportsBatchPublicKey = supportBatchPublicKey(this.device?.features);
+    let responses: SuiAddress[] = [];
+    if (supportsBatchPublicKey) {
+      const publicKeyRes = await batchGetPublickeys(this.device, this.params, 'ed25519', 784);
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const publicKey = publicKeyRes.public_keys[i];
+        let address: string | undefined;
+
+        if (this.shouldConfirm) {
+          const addressRes = await this.device.commands.typedCall(
+            'SuiGetAddress',
+            'SuiAddress',
+            param
+          );
+          address = addressRes.message.address?.toLowerCase();
+        } else {
+          address = publicKeyToAddress(publicKey);
+        }
+
+        const result: SuiAddress = {
+          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('SuiGetAddress', 'SuiAddress', 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/sui/SuiGetPublicKey.ts

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

package/src/api/sui/SuiSignMessage.ts

@@ -0,0 +1,47 @@
+import { SuiSignMessage as HardwareSuiSignMessage } 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 SuiSignMessage extends BaseMethod<HardwareSuiSignMessage> {
+  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 {
+      model_mini: {
+        min: '3.4.0',
+      },
+      model_touch: {
+        min: '4.6.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall('SuiSignMessage', 'SuiMessageSignature', {
+      ...this.params,
+    });
+
+    return Promise.resolve(response.message);
+  }
+}

package/src/api/sui/SuiSignTransaction.ts

@@ -0,0 +1,120 @@
+import { SuiSignTx as HardwareSuiSignTx, TypedCall, SuiSignedTx } from '@ukeyfe/hardware-transport';
+import semver from 'semver';
+import { bytesToHex } from '@noble/hashes/utils';
+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';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
+import { DeviceModelToTypes } from '../../types';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+
+type SuiSignTx = Omit<HardwareSuiSignTx, 'data_initial_chunk' | 'data_length'> & HardwareSuiSignTx;
+
+export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
+  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),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.0.0',
+      },
+      model_touch: {
+        min: '4.3.0',
+      },
+    };
+  }
+
+  supportChunkTransfer() {
+    const deviceType = getDeviceType(this.device.features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+
+    if (DeviceModelToTypes.model_mini.includes(deviceType)) {
+      if (semver.valid(deviceFirmwareVersion)) {
+        return semver.gte(deviceFirmwareVersion, '3.7.0');
+      }
+    } else if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+      if (semver.valid(deviceFirmwareVersion)) {
+        return semver.gte(deviceFirmwareVersion, '4.8.0');
+      }
+    }
+
+    return false;
+  }
+
+  chunkByteSize = 1024;
+
+  processTxRequest = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'SuiSignedTx'> | TypedResponseMessage<'SuiTxRequest'>,
+    data: Buffer,
+    offset = 0
+  ): Promise<SuiSignedTx> => {
+    if (res.type === 'SuiSignedTx') {
+      return res.message;
+    }
+
+    const { data_length } = res.message;
+
+    if (!data_length) {
+      // sign Done
+      return res.message;
+    }
+
+    const payload = data.subarray(offset, offset + data_length);
+    const newOffset = offset + payload.length;
+    const resourceAckParams = {
+      data_chunk: bytesToHex(payload),
+    };
+
+    const response = await typedCall('SuiTxAck', ['SuiSignedTx', 'SuiTxRequest'], {
+      ...resourceAckParams,
+    });
+
+    return this.processTxRequest(typedCall, response, data, newOffset);
+  };
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    let offset = 0;
+    let data: Buffer;
+
+    if (this.supportChunkTransfer()) {
+      offset = this.chunkByteSize;
+      data = Buffer.from(this.params.raw_tx, 'hex');
+      this.params = {
+        address_n: this.params.address_n,
+        raw_tx: '',
+        data_initial_chunk: bytesToHex(data.subarray(0, this.chunkByteSize)),
+        data_length: data.length,
+      };
+    }
+
+    const res = await typedCall('SuiSignTx', ['SuiSignedTx', 'SuiTxRequest'], {
+      ...this.params,
+    });
+
+    // @ts-expect-error
+    return this.processTxRequest(typedCall, res, data, offset);
+  }
+}

package/src/api/sui/normalize.ts

@@ -0,0 +1,28 @@
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+import { blake2b } from '@noble/hashes/blake2b';
+
+export const SUI_ADDRESS_LENGTH = 32;
+export const PUBLIC_KEY_SIZE = 32;
+
+export const SIGNATURE_SCHEME_TO_FLAG = {
+  ED25519: 0x00,
+  Secp256k1: 0x01,
+};
+
+export function normalizeSuiAddress(value: string, forceAdd0x = false): string {
+  let address = value.toLowerCase();
+  if (!forceAdd0x && address.startsWith('0x')) {
+    address = address.slice(2);
+  }
+  return `0x${address.padStart(SUI_ADDRESS_LENGTH * 2, '0')}`.toLowerCase();
+}
+
+export function publicKeyToAddress(publicKey: string) {
+  const tmp = new Uint8Array(PUBLIC_KEY_SIZE + 1);
+  tmp.set([SIGNATURE_SCHEME_TO_FLAG.ED25519]);
+  tmp.set(hexToBytes(publicKey), 1);
+
+  return normalizeSuiAddress(
+    bytesToHex(blake2b(tmp, { dkLen: 32 })).slice(0, SUI_ADDRESS_LENGTH * 2)
+  );
+}

package/src/api/test/TestInitializeDeviceDuration.ts

@@ -0,0 +1,22 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+
+export default class TestInitializeDeviceDuration extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const beginTime = Date.now();
+    await this.device.commands.typedCall('Initialize', 'Features');
+    const endTime = Date.now();
+    const duration = endTime - beginTime;
+    return Promise.resolve(duration);
+  }
+}