@onetokenfe/hd-core 1.1.23

package/src/api/nem/NEMSignTransaction.ts

@@ -0,0 +1,251 @@
+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 {
+  NEMAggregateModification,
+  NEMImportanceTransfer,
+  NEMMosaicCreation,
+  NEMMosaicDefinition,
+  NEMMosaicSupplyChange,
+  NEMProvisionNamespace,
+  NEMSignTx,
+  NEMTransactionCommon,
+  NEMTransfer,
+} from '@onetokenfe/hd-transport';
+import type {
+  NEMAggregateModificationTransaction,
+  NEMImportanceTransaction,
+  NEMMosaicCreationTransaction,
+  NEMProvisionNamespaceTransaction,
+  NEMSupplyChangeTransaction,
+  NEMTransaction,
+  NEMTransferTransaction,
+} from '../../types';
+
+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(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'Unknown transaction type'
+        );
+    }
+
+    return message;
+  };
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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/neo/NeoGetAddress.ts

@@ -0,0 +1,80 @@
+import { BaseMethod } from '../BaseMethod';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { NeoGetAddress as HardwareNeoGetAddress } from '@onetokenfe/hd-transport';
+import type { NeoAddress, NeoGetAddressParams } from '../../types/api/neoGetAddress';
+
+export default class NeoGetAddress extends BaseMethod<HardwareNeoGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: NeoGetAddressParams) => {
+      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 {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: NeoAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NeoGetAddress', 'NeoAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        address: res.message.address ?? '',
+        pub: res.message.public_key ?? '',
+      });
+
+      this.postPreviousAddressMessage({
+        address: res.message.address,
+        path,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/neo/NeoSignTransaction.ts

@@ -0,0 +1,59 @@
+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 { NeoSignTx } from '@onetokenfe/hd-transport';
+
+export default class NeoSignTransaction extends BaseMethod<NeoSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+      { name: 'magicNumber', type: 'number', required: true },
+    ]);
+
+    const { path, rawTx, magicNumber } = this.payload;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+      network_magic: magicNumber,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      pro: {
+        min: '4.12.0',
+      },
+      model_classic1s: {
+        min: '3.11.0',
+      },
+    };
+  }
+
+  async run() {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    this.params = {
+      address_n: this.params.address_n,
+      raw_tx: this.params.raw_tx,
+      network_magic: this.params.network_magic,
+    };
+
+    const res = await typedCall('NeoSignTx', ['NeoSignedTx'], {
+      ...this.params,
+    });
+
+    return {
+      signature: res.message.signature,
+      publicKey: res.message.public_key,
+    };
+  }
+}

package/src/api/nervos/NervosGetAddress.ts

@@ -0,0 +1,80 @@
+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 { NervosGetAddress as HardwareNervosGetAddress } from '@onetokenfe/hd-transport';
+import type { NervosAddress, NervosGetAddressParams } from '../../types';
+
+export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddress[]> {
+  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: NervosGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneToken', type: 'boolean' },
+        { name: 'network', type: 'string' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        network: batch.network,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: NervosAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NervosGetAddress', 'NervosAddress', {
+        ...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/nervos/NervosSignTransaction.ts

@@ -0,0 +1,116 @@
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
+import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@onetokenfe/hd-transport';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+
+type NervosSignTx = Omit<HardwareNervosSignTx, 'data_initial_chunk' | 'data_length'> & {
+  raw_tx: Buffer;
+};
+
+export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+      { name: 'witnessHex', type: 'hexString', required: true },
+      { name: 'network', type: 'string', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx, witnessHex, network } = this.payload as NervosSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      raw_tx: Buffer.from(formatAnyHex(rawTx), 'hex'),
+      witness_buffer: formatAnyHex(witnessHex),
+      network,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.7.0',
+      },
+      model_touch: {
+        min: '4.9.0',
+      },
+    };
+  }
+
+  chunkByteSize = 1024;
+
+  processTxRequest = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'NervosSignedTx'> | TypedResponseMessage<'NervosTxRequest'>,
+    data: Buffer,
+    offset = 0
+  ): Promise<NervosSignedTx> => {
+    if (res.type === 'NervosSignedTx') {
+      if (!res?.message?.signature) {
+        throw new Error('No signature returned');
+      }
+
+      return {
+        ...res.message,
+        path: serializedPath(this.params.address_n),
+      };
+    }
+
+    const { data_length } = res.message;
+
+    if (!data_length) {
+      if (!res?.message?.signature) {
+        throw new Error('No signature returned');
+      }
+      // sign Done
+      return {
+        ...res.message,
+        path: serializedPath(this.params.address_n),
+      };
+    }
+
+    const payload = data.subarray(offset, offset + data_length);
+    const newOffset = offset + payload.length;
+    const resourceAckParams = {
+      data_chunk: bytesToHex(payload),
+    };
+
+    const response = await typedCall('NervosTxAck', ['NervosSignedTx', 'NervosTxRequest'], {
+      ...resourceAckParams,
+    });
+
+    return this.processTxRequest(typedCall, response, data, newOffset);
+  };
+
+  async run() {
+    const dataLength = this.params.raw_tx.length;
+    const offset = dataLength;
+    const data = this.params.raw_tx;
+
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const res = await typedCall('NervosSignTx', 'NervosSignedTx', {
+      address_n: this.params.address_n,
+      data_initial_chunk: bytesToHex(data.subarray(0, offset)),
+      data_length: dataLength,
+      witness_buffer: this.params.witness_buffer,
+      network: this.params.network,
+    });
+
+    return this.processTxRequest(typedCall, res, data, offset);
+  }
+}

package/src/api/nexa/NexaGetAddress.ts

@@ -0,0 +1,88 @@
+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 { NexaGetAddress as HardwareNexaGetAddress } from '@onetokenfe/hd-transport';
+import type { NexaGetAddressParams } from '../../types';
+
+export default class NexaGetAddress extends BaseMethod<HardwareNexaGetAddress[]> {
+  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: NexaGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneToken', type: 'boolean' },
+        { name: 'prefix', type: 'string' },
+        { name: 'scheme', type: 'string' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+        prefix: batch.prefix,
+        // @ts-expect-error
+        scheme: batch.scheme,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.2.0',
+      },
+      model_touch: {
+        min: '4.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: {
+      path: string;
+      pub: string;
+      address: string;
+    }[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NexaGetAddress', 'NexaAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        pub: res.message.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]);
+  }
+}