@ukeyfe/hardware-core 1.1.13

package/src/api/ton/TonGetAddress.ts

@@ -0,0 +1,96 @@
+import { TonGetAddress as HardwareTonGetAddress } 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 { TonAddress, TonGetAddressParams } from '../../types';
+
+export default class TonGetAddress extends BaseMethod<HardwareTonGetAddress[]> {
+  hasBundle = false;
+
+  shouldConfirm = false;
+
+  init() {
+    this.strictCheckDeviceSupport = true;
+    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.hasBundle
+      ? this.payload.bundle.some((i: any) => !!i.showOnOneKey)
+      : false;
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: TonGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'walletVersion' },
+        { name: 'isBounceable', type: 'boolean' },
+        { name: 'isTestnetOnly', type: 'boolean' },
+        { name: 'workchain' },
+        { name: 'walletId', type: 'number' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        wallet_version: batch.walletVersion,
+        is_bounceable: batch.isBounceable,
+        is_testnet_only: batch.isTestnetOnly,
+        workchain: batch.workchain,
+        wallet_id: batch.walletId,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+      model_classic1s: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: TonAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('TonGetAddress', 'TonAddress', {
+        ...param,
+      });
+
+      const { address, public_key } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        publicKey: public_key,
+        pub: public_key,
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    validateResult(responses, ['address', 'pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/ton/TonSignMessage.ts

@@ -0,0 +1,214 @@
+import {
+  TonSignMessage as HardwareTonSignMessage,
+  TonSignedMessage,
+  TonTxAck,
+} from '@ukeyfe/hardware-transport';
+import semver from 'semver';
+import BigNumber from 'bignumber.js';
+import { isEmpty } from 'lodash';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { DeviceFirmwareRange, DeviceModelToTypes, TonSignMessageParams } from '../../types';
+import { getDeviceFirmwareVersion, getDeviceType, getMethodVersionRange } from '../../utils';
+import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+import type { TonSignedMessageResponse } from '../../types/api/tonSignMessage';
+import { cutString } from '../helpers/stringUtils';
+
+export default class TonSignMessage extends BaseMethod<HardwareTonSignMessage> {
+  initState: string | null = null;
+
+  init() {
+    this.strictCheckDeviceSupport = true;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'destination', type: 'string' },
+      { name: 'jettonMasterAddress', type: 'string' },
+      { name: 'jettonWalletAddress', type: 'string' },
+      { name: 'tonAmount' },
+      { name: 'jettonAmount' },
+      { name: 'fwdFee' },
+      { name: 'comment', type: 'string' },
+      { name: 'isRawData', type: 'boolean' },
+      { name: 'mode', type: 'number' },
+      { name: 'seqno', type: 'number' },
+      { name: 'expireAt' },
+      { name: 'walletVersion' },
+      { name: 'walletId', type: 'number' },
+      { name: 'workchain' },
+      { name: 'isBounceable', type: 'boolean' },
+      { name: 'isTestnetOnly', type: 'boolean' },
+      { name: 'extDestination', type: 'array' },
+      { name: 'extTonAmount', type: 'array' },
+      { name: 'extPayload', type: 'array' },
+      { name: 'initState', type: 'hexString' },
+      { name: 'signingMessageRepr', type: 'hexString' },
+    ]);
+
+    const { path } = this.payload as TonSignMessageParams;
+    const addressN = validatePath(path, 3);
+
+    this.initState = stripHexStartZeroes(formatAnyHex(this.payload.initState));
+    const initStateLength = this.initState == null ? 0 : this.initState.length / 2;
+    this.params = {
+      address_n: addressN,
+      destination: this.payload.destination,
+      jetton_master_address: this.payload.jettonMasterAddress,
+      jetton_wallet_address: this.payload.jettonWalletAddress,
+      ton_amount: this.payload.tonAmount,
+      fwd_fee: this.payload.fwdFee,
+      comment: this.payload.comment,
+      mode: this.payload.mode,
+      is_raw_data: this.payload.isRawData,
+      seqno: this.payload.seqno,
+      expire_at: this.payload.expireAt,
+      wallet_version: this.payload.walletVersion,
+      wallet_id: this.payload.walletId,
+      workchain: this.payload.workchain,
+      is_bounceable: this.payload.isBounceable,
+      is_testnet_only: this.payload.isTestnetOnly,
+      ext_destination: this.payload.extDestination,
+      ext_ton_amount: this.payload.extTonAmount,
+      ext_payload: this.payload.extPayload,
+      init_data_length: initStateLength,
+      signing_message_repr: stripHexStartZeroes(formatAnyHex(this.payload.signingMessageRepr)),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+      model_classic1s: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  getSupportJettonAmountBytesVersionRange(): DeviceFirmwareRange {
+    return {
+      pro: {
+        min: '4.10.2',
+      },
+      model_classic1s: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  checkSupportJettonAmountBytes() {
+    const firmwareVersion = getDeviceFirmwareVersion(this.device.features)?.join('.');
+    const versionRange = getMethodVersionRange(
+      this.device.features,
+      type => this.getSupportJettonAmountBytesVersionRange()[type]
+    );
+
+    if (!versionRange) {
+      // Equipment that does not need to be repaired
+      return true;
+    }
+
+    if (semver.valid(firmwareVersion) && semver.gte(firmwareVersion, versionRange.min)) {
+      return true;
+    }
+    return false;
+  }
+
+  getFixCommentErrorVersionRange(): DeviceFirmwareRange {
+    return {
+      pro: {
+        min: '4.10.1',
+      },
+      model_classic1s: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  checkFixCommentError() {
+    const { comment, jettonAmount } = this.payload;
+    this.checkFeatureVersionLimit(
+      () => !isEmpty(comment) && jettonAmount !== null && jettonAmount !== undefined,
+      () => this.getFixCommentErrorVersionRange()
+    );
+  }
+
+  getFixInitStateErrorVersionRange(): DeviceFirmwareRange {
+    return {
+      pro: {
+        min: '4.13.0',
+      },
+      model_classic1s: {
+        min: '3.12.0',
+      },
+    };
+  }
+
+  checkFixInitStateError() {
+    const { initState, signingMessageRepr } = this.payload;
+    this.checkFeatureVersionLimit(
+      () => !isEmpty(initState) && !isEmpty(signingMessageRepr),
+      () => this.getFixInitStateErrorVersionRange()
+    );
+  }
+
+  processTxRequest = async (
+    request: TonSignedMessage,
+    data: string
+  ): Promise<TonTxAck | TonSignedMessageResponse> => {
+    if (!request.init_data_length) {
+      const deviceType = getDeviceType(this.device.features);
+      const hasClassic = DeviceModelToTypes.model_classic1s.includes(deviceType);
+      // use signing_message_repr sign, not exists signning_message, skip validate
+      const hasSigningMessageRepr = request.signning_message == null;
+
+      return Promise.resolve({
+        ...request,
+        skip_validate: hasClassic || hasSigningMessageRepr,
+      });
+    }
+
+    const [first, rest] = cutString(data, request.init_data_length * 2);
+    const response = await this.device.commands.typedCall('TonTxAck', 'TonSignedMessage', {
+      init_data_chunk: first,
+    });
+
+    return this.processTxRequest(response.message, rest);
+  };
+
+  async run() {
+    // checkFixCommentError
+    this.checkFixCommentError();
+    this.checkFixInitStateError();
+
+    // check jettonAmount
+    const { jettonAmount } = this.payload;
+    if (jettonAmount) {
+      if (this.checkSupportJettonAmountBytes()) {
+        this.params.jetton_amount_bytes = stripHexStartZeroes(
+          formatAnyHex(new BigNumber(jettonAmount).toString(16))
+        );
+      } else {
+        this.params.jetton_amount = jettonAmount;
+      }
+    }
+
+    let data = this.initState ?? '';
+    if (this.initState) {
+      const [first, rest] = cutString(data, 1024 * 2);
+      this.params.init_data_initial_chunk = first;
+      data = rest;
+    }
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    const res = await typedCall('TonSignMessage', 'TonSignedMessage', {
+      ...this.params,
+    });
+    return this.processTxRequest(res.message, data);
+  }
+}

package/src/api/ton/TonSignProof.ts

@@ -0,0 +1,62 @@
+import { TonSignProof as HardwareTonSignProof } 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 { TonSignProofParams } from '../../types';
+
+export default class TonSignProof extends BaseMethod<HardwareTonSignProof> {
+  init() {
+    this.strictCheckDeviceSupport = true;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // init params
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'appdomain', type: 'string' },
+      { name: 'comment', type: 'string' },
+      { name: 'expireAt' },
+      { name: 'walletVersion' },
+      { name: 'walletId', type: 'number' },
+      { name: 'workchain' },
+      { name: 'isBounceable', type: 'boolean' },
+      { name: 'isTestnetOnly', type: 'boolean' },
+    ]);
+
+    const { path } = this.payload as TonSignProofParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      appdomain: this.payload.appdomain,
+      comment: this.payload.comment,
+      expire_at: this.payload.expireAt,
+      wallet_version: this.payload.walletVersion,
+      wallet_id: this.payload.walletId,
+      workchain: this.payload.workchain,
+      is_bounceable: this.payload.isBounceable,
+      is_testnet_only: this.payload.isTestnetOnly,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+      model_classic1s: {
+        min: '3.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('TonSignProof', 'TonSignedProof', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/tron/TronGetAddress.ts

@@ -0,0 +1,74 @@
+import { TronGetAddress as HardwareTronGetAddress } 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 { TronGetAddressParams, TronAddress } from '../../types';
+
+export default class TronGetAddress extends BaseMethod<HardwareTronGetAddress[]> {
+  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: TronGetAddressParams) => {
+      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.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: TronAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('TronGetAddress', 'TronAddress', {
+        ...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/tron/TronSignMessage.ts

@@ -0,0 +1,82 @@
+import {
+  TronSignMessage as HardwareTronSignMessage,
+  TronMessageType,
+} 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 { stripHexPrefix } from '../helpers/hexUtils';
+
+export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage> {
+  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 } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    if (this.payload.messageType === 'V1' || this.payload.messageType == null) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotSupportMethod,
+        'not support tron message v1'
+      );
+    }
+
+    const messageType = TronMessageType.V2;
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      message: stripHexPrefix(messageHex),
+      message_type: messageType,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.5.0',
+      },
+    };
+  }
+
+  getMessageV2VersionRange() {
+    return {
+      pro: {
+        min: '4.16.0',
+      },
+      classic1s: {
+        min: '3.13.0',
+      },
+    };
+  }
+
+  async run() {
+    this.checkFeatureVersionLimit(
+      () => this.params.message_type === TronMessageType.V2,
+      () => this.getMessageV2VersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
+    const response = await this.device.commands.typedCall(
+      'TronSignMessage',
+      'TronMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(response.message);
+  }
+}