@onekeyfe/hd-core 0.0.8 → 0.1.0

package/src/api/nem/NEMSignTransaction.ts

@@ -0,0 +1,246 @@
+import {
+  NEMAggregateModification,
+  NEMImportanceTransfer,
+  NEMMosaicCreation,
+  NEMMosaicDefinition,
+  NEMMosaicSupplyChange,
+  NEMProvisionNamespace,
+  NEMSignTx,
+  NEMTransactionCommon,
+  NEMTransfer,
+} from '@onekeyfe/hd-transport/src/types/messages';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  NEMAggregateModificationTransaction,
+  NEMImportanceTransaction,
+  NEMMosaicCreationTransaction,
+  NEMProvisionNamespaceTransaction,
+  NEMSupplyChangeTransaction,
+  NEMTransaction,
+  NEMTransferTransaction,
+} from '../../types';
+import { ERRORS } from '../../constants';
+
+const NEM_TRANSFER = 0x0101;
+const NEM_COSIGNING = 0x0102;
+const NEM_IMPORTANCE_TRANSFER = 0x0801;
+const NEM_AGGREGATE_MODIFICATION = 0x1001;
+const NEM_MULTISIG_SIGNATURE = 0x1002;
+const NEM_MULTISIG = 0x1004;
+const NEM_PROVISION_NAMESPACE = 0x2001;
+const NEM_MOSAIC_CREATION = 0x4001;
+const NEM_SUPPLY_CHANGE = 0x4002;
+
+export default class NEMSignTransaction extends BaseMethod<NEMSignTx> {
+  NEM_MOSAIC_LEVY_TYPES: Record<number, string> = {
+    1: 'MosaicLevy_Absolute',
+    2: 'MosaicLevy_Percentile',
+  };
+
+  NEM_SUPPLY_CHANGE_TYPES: Record<number, string> = {
+    1: 'SupplyChange_Increase',
+    2: 'SupplyChange_Decrease',
+  };
+
+  NEM_AGGREGATE_MODIFICATION_TYPES: Record<number, string> = {
+    1: 'CosignatoryModification_Add',
+    2: 'CosignatoryModification_Delete',
+  };
+
+  NEM_IMPORTANCE_TRANSFER_MODES: Record<number, string> = {
+    1: 'ImportanceTransfer_Activate',
+    2: 'ImportanceTransfer_Deactivate',
+  };
+
+  getCommon = (tx: NEMTransaction, address_n?: number[]): NEMTransactionCommon => ({
+    address_n,
+    // eslint-disable-next-line no-bitwise
+    network: (tx.version >> 24) & 0xff,
+    timestamp: tx.timeStamp,
+    fee: tx.fee,
+    deadline: tx.deadline ?? 0,
+    signer: address_n ? undefined : tx.signer,
+  });
+
+  transferMessage = (tx: NEMTransferTransaction): NEMTransfer => {
+    const mosaics = tx.mosaics
+      ? tx.mosaics.map(mosaic => ({
+          namespace: mosaic.mosaicId.namespaceId,
+          mosaic: mosaic.mosaicId.name,
+          quantity: mosaic.quantity,
+        }))
+      : undefined;
+
+    return {
+      recipient: tx.recipient,
+      amount: tx.amount,
+      payload: tx.message ? tx.message.payload : undefined,
+      public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
+      mosaics,
+    };
+  };
+
+  importanceTransferMessage = (tx: NEMImportanceTransaction): NEMImportanceTransfer => ({
+    // @ts-expect-error
+    mode: this.NEM_IMPORTANCE_TRANSFER_MODES[tx.importanceTransfer.mode],
+    public_key: tx.importanceTransfer.publicKey,
+  });
+
+  aggregateModificationMessage = (
+    tx: NEMAggregateModificationTransaction
+  ): NEMAggregateModification => {
+    const modifications = tx.modifications
+      ? tx.modifications.map(modification => ({
+          type: this.NEM_AGGREGATE_MODIFICATION_TYPES[modification.modificationType],
+          public_key: modification.cosignatoryAccount,
+        }))
+      : undefined;
+
+    return {
+      // @ts-expect-error
+      modifications,
+      relative_change: tx.minCosignatories.relativeChange,
+    };
+  };
+
+  provisionNamespaceMessage = (tx: NEMProvisionNamespaceTransaction): NEMProvisionNamespace => ({
+    namespace: tx.newPart ?? '',
+    parent: tx.parent || undefined,
+    sink: tx.rentalFeeSink ?? '',
+    fee: tx.rentalFee ?? 0,
+  });
+
+  mosaicCreationMessage = (tx: NEMMosaicCreationTransaction): NEMMosaicCreation => {
+    const { levy } = tx.mosaicDefinition;
+
+    const definition: NEMMosaicDefinition = {
+      namespace: tx.mosaicDefinition.id.namespaceId,
+      mosaic: tx.mosaicDefinition.id.name,
+      // @ts-expect-error
+      levy: levy && levy.type ? this.NEM_MOSAIC_LEVY_TYPES[levy.type] : undefined,
+      fee: levy && levy.fee,
+      levy_address: levy && levy.recipient,
+      levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
+      levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
+      description: tx.mosaicDefinition.description,
+    };
+
+    const { properties } = tx.mosaicDefinition;
+    if (Array.isArray(properties)) {
+      properties.forEach(property => {
+        const { name, value } = property;
+        switch (name) {
+          case 'divisibility':
+            definition.divisibility = parseInt(value);
+            break;
+
+          case 'initialSupply':
+            definition.supply = parseInt(value);
+            break;
+
+          case 'supplyMutable':
+            definition.mutable_supply = value === 'true';
+            break;
+
+          case 'transferable':
+            definition.transferable = value === 'true';
+            break;
+          default:
+        }
+      });
+    }
+
+    return {
+      definition,
+      sink: tx.creationFeeSink ?? '',
+      fee: tx.creationFee ?? 0,
+    };
+  };
+
+  supplyChangeMessage = (tx: NEMSupplyChangeTransaction): NEMMosaicSupplyChange => ({
+    namespace: tx.mosaicId.namespaceId,
+    mosaic: tx.mosaicId.name,
+    // @ts-expect-error
+    type: this.NEM_SUPPLY_CHANGE_TYPES[tx.supplyType],
+    delta: tx.delta ?? 0,
+  });
+
+  parseTx = (tx: NEMTransaction, address_n: number[]) => {
+    let transaction = tx;
+    const message: NEMSignTx = {
+      transaction: this.getCommon(tx, address_n),
+      transfer: undefined,
+      importance_transfer: undefined,
+      aggregate_modification: undefined,
+      provision_namespace: undefined,
+      mosaic_creation: undefined,
+      supply_change: undefined,
+    };
+
+    if (
+      tx.type === NEM_COSIGNING ||
+      tx.type === NEM_MULTISIG ||
+      tx.type === NEM_MULTISIG_SIGNATURE
+    ) {
+      message.cosigning = tx.type === NEM_COSIGNING || tx.type === NEM_MULTISIG_SIGNATURE;
+      transaction = tx.otherTrans;
+      message.multisig = this.getCommon(transaction);
+    }
+
+    switch (transaction.type) {
+      case NEM_TRANSFER:
+        message.transfer = this.transferMessage(transaction);
+        break;
+
+      case NEM_IMPORTANCE_TRANSFER:
+        message.importance_transfer = this.importanceTransferMessage(transaction);
+        break;
+
+      case NEM_AGGREGATE_MODIFICATION:
+        message.aggregate_modification = this.aggregateModificationMessage(transaction);
+        break;
+
+      case NEM_PROVISION_NAMESPACE:
+        message.provision_namespace = this.provisionNamespaceMessage(transaction);
+        break;
+
+      case NEM_MOSAIC_CREATION:
+        message.mosaic_creation = this.mosaicCreationMessage(transaction);
+        break;
+
+      case NEM_SUPPLY_CHANGE:
+        message.supply_change = this.supplyChangeMessage(transaction);
+        break;
+
+      default:
+        throw ERRORS.TypedError('Method_InvalidParameter', 'Unknown transaction type');
+    }
+
+    return message;
+  };
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+    const { path, transaction } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    this.params = this.parseTx(transaction, addressN);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('NEMSignTx', 'NEMSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res);
+  }
+}

package/src/api/solana/SolGetAddress.ts

@@ -0,0 +1,59 @@
+import { SolanaGetAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SolanaAddress, SolanaGetAddressParams } from '../../types';
+
+export default class SolGetAddress extends BaseMethod<SolanaGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.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: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  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;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/solana/SolSignTransaction.ts

@@ -0,0 +1,69 @@
+import { SolanaSignTx as HardwareSolanaSignTx } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SolanaSignedTx, SolanaSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class SolSignTransaction extends BaseMethod<HardwareSolanaSignTx[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.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 },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        raw_tx: formatAnyHex(batch.rawTx),
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.9',
+      },
+      mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
+  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/stellar/StellarGetAddress.ts

@@ -0,0 +1,59 @@
+import { StellarGetAddress as HardwareStellarGetAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { StellarGetAddressParams, StellarAddress } from '../../types';
+
+export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.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: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  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;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/stellar/StellarSignTransaction.ts

@@ -0,0 +1,213 @@
+import {
+  StellarSignedTx,
+  StellarSignTx as HardwareStellarSignTx,
+} from '@onekeyfe/hd-transport/src/types/messages';
+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.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'networkPassphrase', type: 'string', required: true },
+      { name: 'transaction', type: 'object', required: true },
+    ]);
+
+    // init params
+    const addressN = validatePath(this.payload.path, 3);
+    const { transaction, networkPassphrase } = this.payload as StellarSignTransactionParams;
+
+    this.params = {
+      address_n: addressN,
+      network_passphrase: networkPassphrase,
+      source_account: transaction.source,
+      fee: transaction.fee,
+      sequence_number: transaction.sequence,
+      num_operations: transaction.operations.length,
+    };
+
+    if (transaction.timebounds) {
+      this.params.timebounds_start = transaction.timebounds.minTime;
+      this.params.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);
+      }
+    });
+
+    console.log('StellarSignTransactionParams', this.params);
+    console.log('StellarSignTransactionOperations', this.operations);
+  }
+
+  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/constants/errors.ts

@@ -3,6 +3,7 @@ export const ERROR_CODES = {
   Method_InvalidParameter: '',
   Call_API: '',
   Call_NotResponse: 'No response data',
+  Method_FirmwareUpdate_DownloadFailed: '',
 
   // device error
   Transport_InvalidProtobuf: '',