@ukeyfe/hardware-core 1.1.13

package/src/api/cardano/helper/cardanoInputs.ts

@@ -0,0 +1,54 @@
+import { validateParams } from '../../helpers/paramsValidator';
+import { validatePath } from '../../helpers/pathUtils';
+import type { PROTO } from '../../../constants';
+
+export type Path = number[];
+
+export type InputWithPath = {
+  input: PROTO.CardanoTxInput;
+  path?: Path;
+};
+
+export type CollateralInputWithPath = {
+  collateralInput: PROTO.CardanoTxCollateralInput;
+  path?: Path;
+};
+
+export const transformInput = (input: any): InputWithPath => {
+  validateParams(input, [
+    { name: 'prev_hash', type: 'string', required: true },
+    { name: 'prev_index', type: 'number', required: true },
+  ]);
+  return {
+    input: {
+      prev_hash: input.prev_hash,
+      prev_index: input.prev_index,
+    },
+    path: input.path ? validatePath(input.path, 5) : undefined,
+  };
+};
+
+export const transformCollateralInput = (collateralInput: any): CollateralInputWithPath => {
+  validateParams(collateralInput, [
+    { name: 'prev_hash', type: 'string', required: true },
+    { name: 'prev_index', type: 'number', required: true },
+  ]);
+  return {
+    collateralInput: {
+      prev_hash: collateralInput.prev_hash,
+      prev_index: collateralInput.prev_index,
+    },
+    path: collateralInput.path ? validatePath(collateralInput.path, 5) : undefined,
+  };
+};
+
+export const transformReferenceInput = (referenceInput: any): PROTO.CardanoTxReferenceInput => {
+  validateParams(referenceInput, [
+    { name: 'prev_hash', type: 'string', required: true },
+    { name: 'prev_index', type: 'number', required: true },
+  ]);
+  return {
+    prev_hash: referenceInput.prev_hash,
+    prev_index: referenceInput.prev_index,
+  };
+};

package/src/api/cardano/helper/cardanoOutputs.ts

@@ -0,0 +1,88 @@
+import { validateParams } from '../../helpers/paramsValidator';
+import { tokenBundleToProto } from './token';
+import { addressParametersToProto, validateAddressParameters } from './addressParameters';
+import { hexStringByteLength, sendChunkedHexString } from './utils';
+import type { PROTO } from '../../../constants';
+import type { AssetGroupWithTokens } from '../../../types/api/cardano';
+
+export type OutputWithData = {
+  output: PROTO.CardanoTxOutput;
+  tokenBundle?: AssetGroupWithTokens[];
+  inlineDatum?: string;
+  referenceScript?: string;
+};
+
+export const transformOutput = (output: any): OutputWithData => {
+  validateParams(output, [
+    { name: 'address', type: 'string' },
+    { name: 'amount', type: 'uint', required: true },
+    { name: 'tokenBundle', type: 'array', allowEmpty: true },
+    { name: 'datumHash', type: 'string' },
+    { name: 'format', type: 'number' },
+    { name: 'inlineDatum', type: 'string' },
+    { name: 'referenceScript', type: 'string' },
+  ]);
+
+  const result: OutputWithData = {
+    output: {
+      amount: output.amount,
+      asset_groups_count: 0,
+      datum_hash: output.datumHash,
+      format: output.format,
+      inline_datum_size: output.inlineDatum ? hexStringByteLength(output.inlineDatum) : undefined,
+      reference_script_size: output.referenceScript
+        ? hexStringByteLength(output.referenceScript)
+        : undefined,
+    },
+    inlineDatum: output.inlineDatum,
+    referenceScript: output.referenceScript,
+  };
+
+  if (output.addressParameters) {
+    validateAddressParameters(output.addressParameters);
+    result.output.address_parameters = addressParametersToProto(output.addressParameters);
+  } else {
+    result.output.address = output.address;
+  }
+
+  if (output.tokenBundle) {
+    result.tokenBundle = tokenBundleToProto(output.tokenBundle);
+    result.output.asset_groups_count = result.tokenBundle.length;
+  } else {
+    result.output.asset_groups_count = 0;
+  }
+
+  return result;
+};
+
+export const sendOutput = async (typedCall: any, outputWithData: OutputWithData) => {
+  const MAX_CHUNK_SIZE = 1024 * 2; // 1024 hex-encoded bytes
+
+  const { output, tokenBundle, inlineDatum, referenceScript } = outputWithData;
+
+  await typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+  if (tokenBundle) {
+    for (const assetGroup of tokenBundle) {
+      await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+        policy_id: assetGroup.policyId,
+        tokens_count: assetGroup.tokens.length,
+      });
+      for (const token of assetGroup.tokens) {
+        await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+      }
+    }
+  }
+
+  if (inlineDatum) {
+    await sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+  }
+
+  if (referenceScript) {
+    await sendChunkedHexString(
+      typedCall,
+      referenceScript,
+      MAX_CHUNK_SIZE,
+      'CardanoTxReferenceScriptChunk'
+    );
+  }
+};

package/src/api/cardano/helper/certificate.ts

@@ -0,0 +1,244 @@
+import { ERRORS, HardwareErrorCode } from '@ukeyfe/hardware-shared';
+import { validateParams } from '../../helpers/paramsValidator';
+import { validatePath } from '../../helpers/pathUtils';
+import type {
+  CardanoCertificate,
+  CardanoPoolParameters,
+  CertificateWithPoolOwnersAndRelays,
+  CardanoPoolMargin,
+  CardanoPoolMetadata,
+  CardanoPoolRelay,
+  CardanoPoolOwner,
+  CardanoDRep,
+} from '../../../types/api/cardano';
+import { PROTO } from '../../../constants';
+
+export type PoolParametersWithOwnersAndRelays = {
+  poolParameters?: PROTO.CardanoPoolParametersType;
+  poolOwners: PROTO.CardanoPoolOwner[];
+  poolRelays: PROTO.CardanoPoolRelayParameters[];
+};
+
+const ipv4AddressToHex = (ipv4Address: string) =>
+  Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
+
+const ipv6AddressToHex = (ipv6Address: string) => ipv6Address.split(':').join('');
+
+const validatePoolMargin = (margin: CardanoPoolMargin) => {
+  validateParams(margin, [
+    { name: 'numerator', type: 'string', required: true },
+    { name: 'denominator', type: 'string', required: true },
+  ]);
+};
+
+const validatePoolMetadata = (metadata: CardanoPoolMetadata) => {
+  validateParams(metadata, [
+    { name: 'url', type: 'string', required: true },
+    { name: 'hash', type: 'string', required: true },
+  ]);
+};
+
+const validatePoolRelay = (relay: CardanoPoolRelay) => {
+  validateParams(relay, [{ name: 'type', type: 'number', required: true }]);
+
+  if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
+    const paramsToValidate: Parameters<typeof validateParams>[1] = [
+      { name: 'port', type: 'number', required: true },
+    ];
+    if (relay.ipv4Address) {
+      paramsToValidate.push({ name: 'ipv4Address', type: 'string', required: false });
+    }
+    if (relay.ipv6Address) {
+      paramsToValidate.push({ name: 'ipv6Address', type: 'string', required: false });
+    }
+
+    validateParams(relay, paramsToValidate);
+
+    if (!relay.ipv4Address && !relay.ipv6Address) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Either ipv4Address or ipv6Address must be supplied'
+      );
+    }
+  } else if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+    validateParams(relay, [
+      { name: 'hostName', type: 'string', required: true },
+      { name: 'port', type: 'number', required: true },
+    ]);
+  } else if (relay.type === PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+    validateParams(relay, [{ name: 'hostName', type: 'string', required: true }]);
+  }
+};
+
+const validatePoolOwners = (owners: CardanoPoolOwner[]) => {
+  owners.forEach(owner => {
+    if (owner.stakingKeyHash) {
+      validateParams(owner, [
+        { name: 'stakingKeyHash', type: 'string', required: !owner.stakingKeyPath },
+      ]);
+    }
+
+    if (owner.stakingKeyPath) {
+      validatePath(owner.stakingKeyPath, 5);
+    }
+
+    if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Either stakingKeyHash or stakingKeyPath must be supplied'
+      );
+    }
+  });
+
+  const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
+  if (ownersAsPathCount !== 1) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'Exactly one pool owner must be given as a path'
+    );
+  }
+};
+
+const validatePoolParameters = (poolParameters: CardanoPoolParameters) => {
+  validateParams(poolParameters, [
+    { name: 'poolId', type: 'string', required: true },
+    { name: 'vrfKeyHash', type: 'string', required: true },
+    { name: 'pledge', type: 'string', required: true },
+    { name: 'cost', type: 'string', required: true },
+    { name: 'margin', type: 'object', required: true },
+    { name: 'rewardAccount', type: 'string', required: true },
+    { name: 'owners', type: 'array', required: true },
+    { name: 'relays', type: 'array', required: true, allowEmpty: true },
+    { name: 'metadata', type: 'object' },
+  ]);
+
+  validatePoolMargin(poolParameters.margin);
+  validatePoolOwners(poolParameters.owners);
+  poolParameters.relays.forEach(validatePoolRelay);
+
+  if (poolParameters.metadata) {
+    validatePoolMetadata(poolParameters.metadata);
+  }
+};
+
+const transformPoolParameters = (
+  poolParameters?: CardanoPoolParameters
+): PoolParametersWithOwnersAndRelays => {
+  if (!poolParameters) {
+    return { poolParameters: undefined, poolOwners: [], poolRelays: [] };
+  }
+
+  validatePoolParameters(poolParameters);
+
+  return {
+    poolParameters: {
+      pool_id: poolParameters.poolId,
+      vrf_key_hash: poolParameters.vrfKeyHash,
+      pledge: poolParameters.pledge,
+      cost: poolParameters.cost,
+      margin_numerator: poolParameters.margin.numerator,
+      margin_denominator: poolParameters.margin.denominator,
+      reward_account: poolParameters.rewardAccount,
+      metadata: poolParameters.metadata,
+      owners_count: poolParameters.owners.length,
+      relays_count: poolParameters.relays.length,
+    },
+    poolOwners: poolParameters.owners.map(owner => ({
+      staking_key_hash: owner.stakingKeyHash,
+      staking_key_path: owner.stakingKeyPath ? validatePath(owner.stakingKeyPath, 5) : undefined,
+    })),
+    poolRelays: poolParameters.relays.map(relay => ({
+      type: relay.type,
+      ipv4_address: relay.ipv4Address ? ipv4AddressToHex(relay.ipv4Address) : undefined,
+      ipv6_address: relay.ipv6Address ? ipv6AddressToHex(relay.ipv6Address) : undefined,
+      host_name: relay.hostName,
+      port: relay.port,
+    })),
+  };
+};
+
+const transformDRep = (dRep: CardanoDRep | undefined): PROTO.CardanoDRep | undefined => {
+  if (!dRep) {
+    return undefined;
+  }
+
+  validateParams(dRep, [
+    { name: 'type', type: 'number', required: true },
+    { name: 'keyHash', type: 'string' },
+    { name: 'scriptHash', type: 'string' },
+  ]);
+
+  if (dRep.type === PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'key_hash must be supplied for key_hash type'
+    );
+  }
+
+  if (dRep.type === PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'script_hash must be supplied for script_hash type'
+    );
+  }
+  return {
+    type: dRep.type,
+    key_hash: dRep.keyHash,
+    script_hash: dRep.scriptHash,
+  };
+};
+
+export const transformCertificate = (
+  certificate: CardanoCertificate
+): CertificateWithPoolOwnersAndRelays => {
+  const paramsToValidate: Parameters<typeof validateParams>[1] = [
+    { name: 'type', type: 'number', required: true },
+  ];
+
+  if (certificate.type !== PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+    paramsToValidate.push({ name: 'scriptHash', type: 'string' });
+    paramsToValidate.push({ name: 'keyHash', type: 'string' });
+  }
+
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_DELEGATION) {
+    paramsToValidate.push({ name: 'pool', type: 'string', required: true });
+  }
+
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+    paramsToValidate.push({ name: 'poolParameters', type: 'object', required: true });
+  }
+
+  if (
+    certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY ||
+    certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY
+  ) {
+    paramsToValidate.push({ name: 'deposit', required: true });
+  }
+
+  if (certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
+    paramsToValidate.push({ name: 'dRep', type: 'object', required: true });
+  }
+
+  validateParams(certificate, paramsToValidate);
+
+  const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(
+    certificate.poolParameters
+  );
+
+  const dRep = transformDRep(certificate.dRep);
+
+  return {
+    certificate: {
+      type: certificate.type,
+      path: certificate.path ? validatePath(certificate.path, 5) : undefined,
+      script_hash: certificate.scriptHash,
+      key_hash: certificate.keyHash,
+      pool: certificate.pool,
+      pool_parameters: poolParameters,
+      deposit: certificate.deposit,
+      drep: dRep,
+    },
+    poolOwners,
+    poolRelays,
+  };
+};

package/src/api/cardano/helper/token.ts

@@ -0,0 +1,43 @@
+import { validateParams } from '../../helpers/paramsValidator';
+import type {
+  CardanoAssetGroup,
+  AssetGroupWithTokens,
+  CardanoToken,
+} from '../../../types/api/cardano';
+import type { PROTO } from '../../../constants';
+
+const validateTokens = (tokenAmounts: CardanoToken[]) => {
+  tokenAmounts.forEach(tokenAmount => {
+    validateParams(tokenAmount, [
+      { name: 'assetNameBytes', type: 'string', required: true },
+      { name: 'amount', type: 'uint' },
+      { name: 'mintAmount', type: 'uint', allowNegative: true },
+    ]);
+  });
+};
+
+const validateTokenBundle = (tokenBundle: CardanoAssetGroup[]) => {
+  tokenBundle.forEach(tokenGroup => {
+    validateParams(tokenGroup, [
+      { name: 'policyId', type: 'string', required: true },
+      { name: 'tokenAmounts', type: 'array', required: true },
+    ]);
+
+    validateTokens(tokenGroup.tokenAmounts);
+  });
+};
+
+export const tokenBundleToProto = (tokenBundle: CardanoAssetGroup[]): AssetGroupWithTokens[] => {
+  validateTokenBundle(tokenBundle);
+  return tokenBundle.map(tokenGroup => ({
+    policyId: tokenGroup.policyId,
+    tokens: tokenAmountsToProto(tokenGroup.tokenAmounts),
+  }));
+};
+
+const tokenAmountsToProto = (tokenAmounts: CardanoToken[]): PROTO.CardanoToken[] =>
+  tokenAmounts.map(tokenAmount => ({
+    asset_name_bytes: tokenAmount.assetNameBytes,
+    amount: tokenAmount.amount,
+    mint_amount: tokenAmount.mintAmount,
+  }));

package/src/api/cardano/helper/utils.ts

@@ -0,0 +1,17 @@
+export const hexStringByteLength = (s: string) => s.length / 2;
+
+export const sendChunkedHexString = async (
+  typedCall: any,
+  data: string,
+  chunkSize: number,
+  messageType: string
+) => {
+  let processedSize = 0;
+  while (processedSize < data.length) {
+    const chunk = data.slice(processedSize, processedSize + chunkSize);
+    await typedCall(messageType, 'CardanoTxItemAck', {
+      data: chunk,
+    });
+    processedSize += chunkSize;
+  }
+};

package/src/api/cardano/helper/witnesses.ts

@@ -0,0 +1,61 @@
+import type { CertificateWithPoolOwnersAndRelays } from '../../../types/api/cardano';
+import { CollateralInputWithPath, InputWithPath, Path } from './cardanoInputs';
+import { PROTO } from '../../../constants';
+
+export const gatherWitnessPaths = (
+  inputsWithPath: InputWithPath[],
+  certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[],
+  withdrawals: PROTO.CardanoTxWithdrawal[],
+  collateralInputsWithPath: CollateralInputWithPath[],
+  requiredSigners: PROTO.CardanoTxRequiredSigner[],
+  additionalWitnessRequests: Path[],
+  signingMode: PROTO.CardanoTxSigningMode
+): Path[] => {
+  const witnessPaths = new Map<string, Path>();
+  function _insert(path: Path) {
+    const pathKey = JSON.stringify(path);
+    witnessPaths.set(pathKey, path);
+  }
+
+  // don't gather paths from tx elements in MULTISIG_TRANSACTION signing mode
+  if (signingMode !== PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
+    inputsWithPath.forEach(({ path }) => {
+      if (path) _insert(path);
+    });
+
+    certificatesWithPoolOwnersAndRelays.forEach(({ certificate, poolOwners }) => {
+      if (
+        certificate.path &&
+        (certificate.type === PROTO.CardanoCertificateType.STAKE_DELEGATION ||
+          certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION)
+      ) {
+        _insert(certificate.path);
+      }
+      poolOwners.forEach(poolOwner => {
+        if (poolOwner.staking_key_path) _insert(poolOwner.staking_key_path);
+      });
+    });
+
+    withdrawals.forEach(({ path }) => {
+      if (path) _insert(path);
+    });
+  }
+
+  // gather Plutus-related paths
+  if (signingMode === PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
+    collateralInputsWithPath.forEach(({ path }) => {
+      if (path) _insert(path);
+    });
+  }
+
+  requiredSigners.forEach(({ key_path }) => {
+    if (key_path) _insert(key_path);
+  });
+
+  // add additional witness requests in all cases (because of minting)
+  additionalWitnessRequests.forEach(path => {
+    _insert(path);
+  });
+
+  return Array.from(witnessPaths.values());
+};

package/src/api/conflux/ConfluxGetAddress.ts

@@ -0,0 +1,77 @@
+import { ConfluxGetAddress as HardwareConfluxGetAddress } 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 { ConfluxAddress, ConfluxGetAddressParams } from '../../types/api/confluxGetAddress';
+
+export default class ConfluxGetAddress extends BaseMethod<HardwareConfluxGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    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: ConfluxGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'chainId', type: 'number' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        chain_id: batch.chainId ?? 1029,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ConfluxAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ConfluxGetAddress', 'ConfluxAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        ...res.message,
+      });
+
+      this.postPreviousAddressMessage({
+        path,
+        address: res.message.address,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/conflux/ConfluxSignMessage.ts

@@ -0,0 +1,48 @@
+import { ConfluxSignMessage as HardwareConfluxSignMessage } 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 { formatAnyHex } from '../helpers/hexUtils';
+
+export default class ConfluxSignMessage extends BaseMethod<HardwareConfluxSignMessage> {
+  init() {
+    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),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'ConfluxSignMessage',
+      'ConfluxMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/conflux/ConfluxSignMessageCIP23.ts

@@ -0,0 +1,48 @@
+import { ConfluxSignMessageCIP23 as HardwareConfluxSignMessageCIP23 } 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 { formatAnyHex } from '../helpers/hexUtils';
+
+export default class ConfluxSignMessageCIP23 extends BaseMethod<HardwareConfluxSignMessageCIP23> {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'domainHash', type: 'hexString', required: true },
+      { name: 'messageHash', type: 'hexString', required: true },
+    ]);
+
+    const { path, domainHash, messageHash } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      domain_hash: formatAnyHex(domainHash),
+      message_hash: formatAnyHex(messageHash),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'ConfluxSignMessageCIP23',
+      'ConfluxMessageSignature',
+      {
+        ...this.params,
+      }
+    );
+
+    return Promise.resolve(res.message);
+  }
+}