@ukeyfe/hardware-core 1.1.13

package/src/api/nostr/NostrGetPublicKey.ts

@@ -0,0 +1,73 @@
+import { NostrGetPublicKey as GetPublicKey } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import { NostrPublicKey } from '../../types/api/nostrGetPublicKey';
+
+export default class NostrGetPublicKey extends BaseMethod<GetPublicKey[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    this.hasBundle = Object.prototype.hasOwnProperty.call(this.payload, 'bundle');
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+
+    payload.bundle.forEach((batch: BTCGetAddressParams) => {
+      const addressN = validatePath(batch.path, 1);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.6.0',
+      },
+      model_touch: {
+        min: '4.7.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: NostrPublicKey[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NostrGetPublicKey', 'NostrPublicKey', {
+        ...param,
+      });
+
+      const response = {
+        path: serializedPath(param.address_n),
+        npub: res.message.npub,
+        pub: res.message.publickey,
+        publickey: res.message.publickey,
+      };
+
+      responses.push(response);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/nostr/NostrSignEvent.ts

@@ -0,0 +1,63 @@
+import { NostrSignEvent as SignEvent } from '@ukeyfe/hardware-transport';
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { validateEvent } from './helper';
+import { bytesToHex, hexToBytes } from '../helpers/hexUtils';
+
+export default class NostrSignEvent extends BaseMethod<SignEvent> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    if (!validateEvent(payload.event)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Can't serialize event with wrong or missing properties`
+      );
+    }
+    validateParams(payload, [{ name: 'path', required: true }]);
+    const addressN = validatePath(payload.path, 5);
+
+    this.params = {
+      address_n: addressN,
+      event: bytesToHex(Buffer.from(JSON.stringify(payload.event, null, 0), 'utf-8')),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.6.0',
+      },
+      model_touch: {
+        min: '4.7.0',
+      },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'NostrSignEvent',
+      'NostrSignedEvent',
+      this.params
+    );
+
+    try {
+      const signedEvent = Buffer.from(hexToBytes(message.event)).toString('utf-8');
+      const event = JSON.parse(signedEvent);
+      return {
+        path: serializedPath(this.params.address_n),
+        rawTx: message.event,
+        event,
+      };
+    } catch (e) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'Failed to parse signed event', e);
+    }
+  }
+}

package/src/api/nostr/NostrSignSchnorr.ts

@@ -0,0 +1,51 @@
+import { NostrSignSchnorr as SignSchnorr } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+export default class NostrSignSchnorr extends BaseMethod<SignSchnorr> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'path', required: true },
+      { name: 'hash', required: true, type: 'string' },
+    ]);
+    const addressN = validatePath(payload.path, 5);
+
+    this.params = {
+      address_n: addressN,
+      hash: payload.hash,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.6.0',
+      },
+      model_touch: {
+        min: '4.7.0',
+      },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'NostrSignSchnorr',
+      'NostrSignedSchnorr',
+      this.params
+    );
+
+    return {
+      path: serializedPath(this.params.address_n),
+      rawHash: this.params.hash,
+      signature: message.signature,
+    };
+  }
+}

package/src/api/nostr/helper/index.ts

@@ -0,0 +1,28 @@
+import { NostrEvent } from '../../../types/api/nostrSignEvent';
+
+export function validateEvent(event: NostrEvent): boolean {
+  if (!(event instanceof Object)) return false;
+  if (typeof event.kind !== 'number') return false;
+  if (typeof event.content !== 'string') return false;
+  if (typeof event.created_at !== 'number') return false;
+  // ignore pubkey checks because if the pubkey is not set we add it to the event. same for the ID.
+
+  if (!Array.isArray(event.tags)) return false;
+  for (let i = 0; i < event.tags.length; i += 1) {
+    const tag = event.tags[i];
+    if (!Array.isArray(tag)) return false;
+    for (let j = 0; j < tag.length; j += 1) {
+      if (typeof tag[j] === 'object') return false;
+    }
+  }
+
+  return true;
+}
+
+export function serializeEvent(event: NostrEvent): string {
+  if (!validateEvent(event))
+    throw new Error("can't serialize event with wrong or missing properties");
+
+  // https://github.com/nostr-protocol/nips/blob/master/01.md
+  return JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content]);
+}

package/src/api/polkadot/PolkadotGetAddress.ts

@@ -0,0 +1,83 @@
+import { PolkadotGetAddress as HardwarePolkadotGetAddress } from '@ukeyfe/hardware-transport';
+
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { PolkadotAddress, PolkadotGetAddressParams } from '../../types';
+import { getPolkadotVersionRangeWithBundle } from './networks';
+
+export default class PolkadotGetAddress extends BaseMethod<HardwarePolkadotGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    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: PolkadotGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'prefix', required: true },
+        { name: 'network', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+      const { prefix, network } = batch;
+
+      this.params.push({
+        address_n: addressN,
+        prefix,
+        network,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    const networks = this.params.map(param => param.network);
+    return getPolkadotVersionRangeWithBundle(networks);
+  }
+
+  async run() {
+    // TODO: add batch support
+    const responses: PolkadotAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('PolkadotGetAddress', 'PolkadotAddress', {
+        ...param,
+      });
+
+      const { address, public_key } = res.message;
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        address,
+        pub: public_key ?? '',
+        publicKey: public_key ?? '',
+      });
+
+      this.postPreviousAddressMessage({
+        path,
+        address,
+      });
+    }
+
+    validateResult(responses, ['address', 'pub'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/polkadot/PolkadotSignTransaction.ts

@@ -0,0 +1,50 @@
+import { PolkadotSignTx as HardwarePolkadotSignTx } from '@ukeyfe/hardware-transport';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { PolkadotSignTransactionParams } from '../../types';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { getPolkadotVersionRange } from './networks';
+
+export default class PolkadotSignTransaction extends BaseMethod<HardwarePolkadotSignTx> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'network', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx, network } = this.payload as PolkadotSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      network,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return getPolkadotVersionRange(this.params.network);
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('PolkadotSignTx', 'PolkadotSignedTx', {
+      ...this.params,
+    });
+
+    const { signature } = res.message;
+
+    return {
+      path: serializedPath(this.params.address_n),
+      signature,
+    };
+  }
+}

package/src/api/polkadot/networks.ts

@@ -0,0 +1,56 @@
+import type { DeviceFirmwareRange } from '../../types';
+
+// 100% sure which networks are supported
+enum Networks {
+  Polkadot = 'polkadot',
+  Westend = 'westend',
+  Kusama = 'kusama',
+  Astar = 'astar',
+  JoyStream = 'joystream',
+  Manta = 'manta',
+}
+
+// All polkadot networks are included in no special case
+const baseVersionRange = {
+  model_mini: {
+    min: '3.0.0',
+  },
+  model_touch: {
+    min: '4.3.0',
+  },
+};
+
+const specialVersionRange: Record<string, DeviceFirmwareRange> = {
+  [Networks.JoyStream]: {
+    model_mini: {
+      min: '3.6.0',
+    },
+    model_touch: {
+      min: '4.7.0',
+    },
+  },
+  [Networks.Manta]: {
+    model_mini: {
+      min: '3.7.0',
+    },
+    model_touch: {
+      min: '4.9.0',
+    },
+  },
+};
+
+export default Networks;
+
+export function getPolkadotVersionRange(network: string) {
+  return specialVersionRange[network] ?? baseVersionRange;
+}
+
+export function getPolkadotVersionRangeWithBundle(networks: string[]) {
+  if (networks.includes(Networks.JoyStream)) {
+    return specialVersionRange[Networks.JoyStream];
+  }
+  if (networks.includes(Networks.Manta)) {
+    return specialVersionRange[Networks.Manta];
+  }
+  return baseVersionRange;
+}

package/src/api/scdo/ScdoGetAddress.ts

@@ -0,0 +1,75 @@
+import { ScdoGetAddress as HardwareScdoGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { 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: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  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,44 @@
+import { ScdoSignMessage as HardwareScdoSignMessage } from '@ukeyfe/hardware-transport';
+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';
+
+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,100 @@
+import { ScdoSignTx as HardwareScdoSignTx, TypedCall, ScdoSignedTx } from '@ukeyfe/hardware-transport';
+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 { ScdoSignTransactionParams } from '../../types';
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+
+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,67 @@
+import { SolanaGetAddress } from '@ukeyfe/hardware-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { 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: '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;
+
+      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]);
+  }
+}