@onetokenfe/hd-core 1.1.23

package/src/api/nexa/NexaSignTransaction.ts

@@ -0,0 +1,107 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { TypedCall } from '@onetokenfe/hd-transport';
+import type { NexaSignTransactionParams, NexaSignature } from '../../types';
+
+export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
+  hasBundle = false;
+
+  init() {
+    const payload = this.payload as NexaSignTransactionParams;
+
+    payload.inputs.forEach(input => {
+      validateParams(input, [
+        { name: 'path', type: 'string', required: true },
+        { name: 'message', type: 'string', required: true },
+        { name: 'prefix', type: 'string', required: true },
+      ]);
+      return input;
+    });
+    this.params = payload;
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.2.0',
+      },
+      model_touch: {
+        min: '4.4.0',
+      },
+    };
+  }
+
+  async processTxRequest(
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'NexaTxInputRequest'> | TypedResponseMessage<'NexaSignedTx'>,
+    index: number,
+    signatures: NexaSignature[]
+  ): Promise<NexaSignature[]> {
+    const { signature } = res.message;
+    if (!signature) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        'signature is not valid'
+      );
+    }
+    if (res.type === 'NexaSignedTx') {
+      signatures.push({
+        index,
+        signature,
+      });
+
+      return signatures;
+    }
+
+    if (res.type === 'NexaTxInputRequest') {
+      signatures.push({
+        index,
+        signature,
+      });
+
+      const nextIndex = res.message.request_index;
+      const input = this.params.inputs[nextIndex];
+      const response = await typedCall(
+        'NexaTxInputAck',
+        // @ts-expect-error
+        ['NexaTxInputRequest', 'NexaSignedTx'],
+        {
+          address_n: input.path,
+          raw_message: input.message,
+        }
+      );
+
+      // @ts-expect-error
+      return this.processTxRequest(typedCall, response, nextIndex, signatures);
+    }
+
+    return signatures;
+  }
+
+  async run() {
+    const { device, params } = this;
+    const input = params.inputs[0];
+
+    const response = await device.commands.typedCall(
+      'NexaSignTx',
+      ['NexaTxInputRequest', 'NexaSignedTx'],
+      {
+        address_n: validatePath(input.path, 3),
+        raw_message: input.message,
+        prefix: input.prefix,
+        input_count: params.inputs.length,
+      }
+    );
+    return this.processTxRequest(
+      device.commands.typedCall.bind(device.commands),
+      response as any,
+      0,
+      []
+    );
+  }
+}

package/src/api/nostr/NostrDecryptMessage.ts

@@ -0,0 +1,57 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { NostrDecryptMessage as DecryptMessage } from '@onetokenfe/hd-transport';
+
+export default class NostrDecryptMessage extends BaseMethod<DecryptMessage> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'path', required: true },
+      { name: 'pubkey', required: true, type: 'string' },
+      { name: 'ciphertext', required: true, type: 'string' },
+      { name: 'showOnOneToken', type: 'boolean' },
+    ]);
+    const addressN = validatePath(payload.path, 5);
+
+    this.params = {
+      address_n: addressN,
+      pubkey: payload.pubkey,
+      msg: payload.ciphertext,
+      show_display: payload.showOnOneToken ?? true,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.6.0',
+      },
+      model_touch: {
+        min: '4.7.0',
+      },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'NostrDecryptMessage',
+      'NostrDecryptedMessage',
+      this.params
+    );
+
+    return {
+      path: serializedPath(this.params.address_n),
+      pubkey: this.params.pubkey,
+      ciphertext: this.params.msg,
+      decryptedMessage: message.msg,
+    };
+  }
+}

package/src/api/nostr/NostrEncryptMessage.ts

@@ -0,0 +1,57 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { NostrEncryptMessage as EncryptMessage } from '@onetokenfe/hd-transport';
+
+export default class NostrEncryptMessage extends BaseMethod<EncryptMessage> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    const { payload } = this;
+    validateParams(payload, [
+      { name: 'path', required: true },
+      { name: 'pubkey', required: true, type: 'string' },
+      { name: 'plaintext', required: true, type: 'string' },
+      { name: 'showOnOneToken', type: 'boolean' },
+    ]);
+    const addressN = validatePath(payload.path, 5);
+
+    this.params = {
+      address_n: addressN,
+      pubkey: payload.pubkey,
+      msg: payload.plaintext,
+      show_display: payload.showOnOneToken ?? true,
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.6.0',
+      },
+      model_touch: {
+        min: '4.7.0',
+      },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'NostrEncryptMessage',
+      'NostrEncryptedMessage',
+      this.params
+    );
+
+    return {
+      path: serializedPath(this.params.address_n),
+      pubkey: this.params.pubkey,
+      plaintext: this.params.msg,
+      encryptedMessage: message.msg,
+    };
+  }
+}

package/src/api/nostr/NostrGetPublicKey.ts

@@ -0,0 +1,74 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { NostrGetPublicKey as GetPublicKey } from '@onetokenfe/hd-transport';
+import type { BTCGetAddressParams } from '../../types/api/btcGetAddress';
+import type { 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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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,65 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-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';
+
+import type { NostrSignEvent as SignEvent } from '@onetokenfe/hd-transport';
+
+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,52 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+
+import type { NostrSignSchnorr as SignSchnorr } from '@onetokenfe/hd-transport';
+
+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 type { 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 { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { getPolkadotVersionRangeWithBundle, parseNetwork } from './networks';
+
+import type { PolkadotGetAddress as HardwarePolkadotGetAddress } from '@onetokenfe/hd-transport';
+import type { PolkadotAddress, PolkadotGetAddressParams } from '../../types';
+
+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: 'showOnOneToken', type: 'boolean' },
+      ]);
+
+      const showOnOneToken = batch.showOnOneToken ?? true;
+      const { prefix, network } = batch;
+
+      this.params.push({
+        address_n: addressN,
+        prefix,
+        network: parseNetwork(network),
+        show_display: showOnOneToken,
+      });
+    });
+  }
+
+  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,53 @@
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+import { getPolkadotVersionRange, parseNetwork } from './networks';
+
+import type { PolkadotSignTransactionParams } from '../../types';
+import type { PolkadotSignTx as HardwarePolkadotSignTx } from '@onetokenfe/hd-transport';
+
+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: 'prefix' },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    // init params
+    const { path, rawTx, network, prefix } = this.payload as PolkadotSignTransactionParams;
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      network: parseNetwork(network),
+      prefix,
+      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,72 @@
+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',
+  Hydration = 'hydration',
+  Bifrost = 'bifrost',
+  BifrostKusama = 'bifrost-ksm',
+  PolkadotAssetHub = 'polkadot-assethub',
+  KusamaAssetHub = 'kusama-assethub',
+}
+
+// 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;
+}
+
+export function parseNetwork(network: string) {
+  switch (network) {
+    case Networks.PolkadotAssetHub:
+      return Networks.Polkadot;
+    case Networks.KusamaAssetHub:
+      return Networks.Kusama;
+    default:
+      return network;
+  }
+}