@onetokenfe/hd-core 1.1.23

package/src/api/scdo/ScdoGetAddress.ts

@@ -0,0 +1,76 @@
+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 { ScdoGetAddress as HardwareScdoGetAddress } from '@onetokenfe/hd-transport';
+import type { ScdoAddress, ScdoGetAddressParams } from '../../types';
+
+export default class ScdoGetAddress extends BaseMethod<HardwareScdoGetAddress[]> {
+  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: ScdoGetAddressParams) => {
+      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_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ScdoAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ScdoGetAddress', 'ScdoAddress', {
+        ...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/scdo/ScdoSignMessage.ts

@@ -0,0 +1,45 @@
+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';
+
+import type { ScdoSignMessage as HardwareScdoSignMessage } from '@onetokenfe/hd-transport';
+
+export default class ScdoSignMessage extends BaseMethod<HardwareScdoSignMessage> {
+  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_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  async run() {
+    const response = await this.device.commands.typedCall('ScdoSignMessage', 'ScdoSignedMessage', {
+      ...this.params,
+    });
+
+    return Promise.resolve(response.message);
+  }
+}

package/src/api/scdo/ScdoSignTransaction.ts

@@ -0,0 +1,106 @@
+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, stripHexStartZeroes } from '../helpers/hexUtils';
+
+import type { ScdoSignTransactionParams } from '../../types';
+import type {
+  ScdoSignTx as HardwareScdoSignTx,
+  ScdoSignedTx,
+  TypedCall,
+} from '@onetokenfe/hd-transport';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+
+export default class ScdoSignTransaction extends BaseMethod<HardwareScdoSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'nonce', required: true },
+      { name: 'gasPrice', required: true, type: 'string' },
+      { name: 'gasLimit', required: true, type: 'string' },
+      { name: 'to', required: true, type: 'string' },
+      { name: 'value', required: true, type: 'string' },
+      { name: 'timestamp', required: true, type: 'string' },
+      { name: 'data', type: 'hexString' },
+      { name: 'txType', type: 'number' },
+    ]);
+
+    const { path, nonce, gasPrice, gasLimit, to, value, timestamp, txType } = this
+      .payload as ScdoSignTransactionParams;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      nonce: stripHexStartZeroes(formatAnyHex(nonce)),
+      gas_price: stripHexStartZeroes(formatAnyHex(gasPrice)),
+      gas_limit: stripHexStartZeroes(formatAnyHex(gasLimit)),
+      to,
+      value: stripHexStartZeroes(formatAnyHex(value)),
+      timestamp: timestamp ? stripHexStartZeroes(formatAnyHex(timestamp)) : undefined,
+      tx_type: txType,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_touch: {
+        min: '4.10.0',
+      },
+    };
+  }
+
+  chunkByteSize = 1024;
+
+  processTxRequest = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ScdoSignedTx'>,
+    data: Buffer,
+    offset = 0
+  ): Promise<ScdoSignedTx> => {
+    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('ScdoTxAck', 'ScdoSignedTx', {
+      ...resourceAckParams,
+    });
+
+    return this.processTxRequest(typedCall, response, data, newOffset);
+  };
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const rawData = this.payload?.data;
+    const data = rawData && Buffer.from(stripHexStartZeroes(formatAnyHex(rawData)), 'hex');
+    const offset = this.chunkByteSize;
+    if (data && data.length > 0) {
+      this.params.data_initial_chunk = bytesToHex(data.subarray(0, this.chunkByteSize));
+      this.params.data_length = data.length;
+    }
+
+    const res = await typedCall('ScdoSignTx', ['ScdoSignedTx'], {
+      ...this.params,
+    });
+
+    return this.processTxRequest(typedCall, res, data, offset);
+  }
+}

package/src/api/solana/SolGetAddress.ts

@@ -0,0 +1,68 @@
+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 { SolanaGetAddress } from '@onetokenfe/hd-transport';
+import type { SolanaAddress, SolanaGetAddressParams } from '../../types';
+
+export default class SolGetAddress extends BaseMethod<SolanaGetAddress[]> {
+  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: SolanaGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  async run() {
+    const responses: SolanaAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('SolanaGetAddress', 'SolanaAddress', {
+        ...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/solana/SolSignMessage.ts

@@ -0,0 +1,61 @@
+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';
+
+import type { SolanaSignUnsafeMessage as HardwareSolSignUnsafeMessage } from '@onetokenfe/hd-transport';
+
+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,61 @@
+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';
+
+import type { SolanaSignOffChainMessage as HardwareSolSignOffChainMessage } from '@onetokenfe/hd-transport';
+
+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,108 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+import type { SolanaSignTransactionParams, SolanaSignedTx } from '../../types';
+import type { SolanaSignTx as HardwareSolanaSignTx } from '@onetokenfe/hd-transport';
+
+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 },
+        { name: 'extraInfo', type: 'object' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        raw_tx: formatAnyHex(batch.rawTx),
+        ...(batch.extraInfo ? { extra_info: batch.extraInfo } : undefined),
+      });
+    });
+  }
+
+  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,69 @@
+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 { StarcoinGetAddress as HardwareStarcoinGetAddress } from '@onetokenfe/hd-transport';
+import type { 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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,70 @@
+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 { StarcoinGetPublicKey as HardwareStarcoinGetPublicKey } from '@onetokenfe/hd-transport';
+import type {
+  StarcoinGetPublicKeyParams,
+  StarcoinPublicKey,
+} 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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]);
+  }
+}