@onetokenfe/hd-core 1.1.23

package/src/api/starcoin/StarcoinSignMessage.ts

@@ -0,0 +1,42 @@
+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 type { StarcoinSignMessage as HardwareStarcoinSignMessage } from '@onetokenfe/hd-transport';
+
+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,38 @@
+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 type { StarcoinSignTx } from '@onetokenfe/hd-transport';
+
+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,35 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+import type { StarcoinVerifyMessage as HardwareStarcoinVerifyMessage } from '@onetokenfe/hd-transport';
+
+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,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 { StellarGetAddress as HardwareStellarGetAddress } from '@onetokenfe/hd-transport';
+import type { StellarAddress, StellarGetAddressParams } 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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]);
+  }
+}

package/src/api/stellar/StellarSignTransaction.ts

@@ -0,0 +1,220 @@
+import { StellarMemoType } from '@onetokenfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type {
+  StellarSignTx as HardwareStellarSignTx,
+  StellarSignedTx,
+} from '@onetokenfe/hd-transport';
+import type { 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 { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { publicKeyToAddress } from './normalize';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+import type { SuiAddress, SuiGetAddressParams } from '../../types';
+import type { SuiGetAddress as HardwareSuiGetAddress } from '@onetokenfe/hd-transport';
+
+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.showOnOneToken ||
+      this.payload.bundle?.some((i: SuiGetAddressParams) => !!i.showOnOneToken);
+
+    // 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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,66 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+
+import type { SuiGetAddressParams, SuiPublicKey } from '../../types';
+
+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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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,48 @@
+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 { SuiSignMessage as HardwareSuiSignMessage } from '@onetokenfe/hd-transport';
+
+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);
+  }
+}