@onetokenfe/hd-core 1.1.23

package/src/api/sui/SuiSignTransaction.ts

@@ -0,0 +1,126 @@
+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 {
+  SuiSignTx as HardwareSuiSignTx,
+  SuiSignedTx,
+  TypedCall,
+} from '@onetokenfe/hd-transport';
+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);
+  }
+}

package/src/api/ton/TonGetAddress.ts

@@ -0,0 +1,96 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+
+import type { TonGetAddress as HardwareTonGetAddress } from '@onetokenfe/hd-transport';
+import type { 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.showOnOneToken)
+      : 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: 'showOnOneToken', type: 'boolean' },
+        { name: 'walletVersion' },
+        { name: 'isBounceable', type: 'boolean' },
+        { name: 'isTestnetOnly', type: 'boolean' },
+        { name: 'workchain' },
+        { name: 'walletId', type: 'number' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        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,217 @@
+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 { DeviceModelToTypes } from '../../types';
+import { getDeviceFirmwareVersion, getDeviceType, getMethodVersionRange } from '../../utils';
+import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+import { cutString } from '../helpers/stringUtils';
+
+import type { DeviceFirmwareRange, TonSignMessageParams } from '../../types';
+import type {
+  TonSignMessage as HardwareTonSignMessage,
+  TonSignedMessage,
+  TonTxAck,
+} from '@onetokenfe/hd-transport';
+import type { TonSignedMessageResponse } from '../../types/api/tonSignMessage';
+
+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 { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { TonSignProof as HardwareTonSignProof } from '@onetokenfe/hd-transport';
+import type { 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,75 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+
+import type { TronGetAddress as HardwareTronGetAddress } from '@onetokenfe/hd-transport';
+import type { TronAddress, TronGetAddressParams } 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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]);
+  }
+}