@onekeyfe/hd-core 0.2.7 → 0.2.9

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

@@ -0,0 +1,56 @@
+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 = {
+  // @ts-expect-error
+  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,
+  };
+};
+
+// @ts-expect-error
+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,89 @@
+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,
+      // @ts-expect-error
+      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,199 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { validateParams } from '../../helpers/paramsValidator';
+import { validatePath } from '../../helpers/pathUtils';
+import type {
+  CardanoCertificate,
+  CardanoPoolParameters,
+  CertificateWithPoolOwnersAndRelays,
+  CardanoPoolMargin,
+  CardanoPoolMetadata,
+  CardanoPoolRelay,
+  CardanoPoolOwner,
+} 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 {
+    // @ts-expect-error
+    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,
+    })),
+  };
+};
+
+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 });
+  }
+
+  validateParams(certificate, paramsToValidate);
+
+  const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(
+    certificate.poolParameters
+  );
+
+  return {
+    certificate: {
+      type: certificate.type,
+      path: certificate.path ? validatePath(certificate.path, 5) : undefined,
+      script_hash: certificate.scriptHash,
+      // @ts-expect-error
+      key_hash: certificate.keyHash,
+      pool: certificate.pool,
+      pool_parameters: poolParameters,
+    },
+    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,63 @@
+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[],
+  // @ts-expect-error
+  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
+  // @ts-expect-error
+  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/firmware/uploadFirmware.ts

@@ -2,7 +2,7 @@ import { blake2s } from '@noble/hashes/blake2s';
 import JSZip from 'jszip';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { Success } from '@onekeyfe/hd-transport';
-import { wait, getLogger, LoggerNames } from '../../utils/index';
+import { wait } from '../../utils/index';
 import { DEVICE, CoreMessage, createUiMessage, UI_REQUEST } from '../../events';
 import { PROTO } from '../../constants';
 import type { Device } from '../../device/Device';
@@ -10,8 +10,6 @@ import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommand
 import { KnownDevice } from '../../types';
 import { bytesToHex } from '../helpers/hexUtils';
 
-const Log = getLogger(LoggerNames.Device);
-
 const postConfirmationMessage = (device: Device) => {
   // only if firmware is already installed. fresh device does not require button confirmation
   if (device.features?.firmware_present) {

package/src/api/helpers/paramsValidator.ts

@@ -10,12 +10,14 @@ export type SchemaParam = {
     | 'number'
     | 'boolean'
     | 'bigNumber'
+    | 'uint'
     | 'buffer'
     | 'object'
     | 'array'
     | 'hexString';
   required?: boolean;
   allowEmpty?: boolean;
+  allowNegative?: boolean;
 };
 
 const invalidParameter = (message: string) =>
@@ -42,7 +44,23 @@ export const validateParams = (values: any, fields: Array<SchemaParam>): void =>
             throw invalidParameter(`Parameter "${field.name}" is empty.`);
           }
           break;
-
+        case 'uint':
+          if (typeof value !== 'string' && typeof value !== 'number') {
+            throw invalidParameter(
+              `Parameter [${field.name}] has invalid type. "string|number" expected.`
+            );
+          }
+          if (
+            (typeof value === 'number' && !Number.isSafeInteger(value)) ||
+            !/^(?:[1-9]\d*|\d)$/.test(
+              value.toString().replace(/^-/, field.allowNegative ? '' : '-')
+            )
+          ) {
+            throw invalidParameter(
+              `Parameter [${field.name}] has invalid value "${value}". Integer representation expected.`
+            );
+          }
+          break;
         case 'bigNumber':
           if (typeof value !== 'string') {
             throw invalidParameter(

package/src/api/index.ts

@@ -81,3 +81,11 @@ export { default as cosmosSignTransaction } from './cosmos/CosmosSignTransaction
 
 export { default as xrpGetAddress } from './xrp/XrpGetAddress';
 export { default as xrpSignTransaction } from './xrp/XrpSignTransaction';
+
+export { default as suiGetAddress } from './sui/SuiGetAddress';
+export { default as suiGetPublicKey } from './sui/SuiGetPublicKey';
+export { default as suiSignTransaction } from './sui/SuiSignTransaction';
+
+export { default as cardanoGetAddress } from './cardano/CardanoGetAddress';
+export { default as cardanoGetPublicKey } from './cardano/CardanoGetPublicKey';
+export { default as cardanoSignTransaction } from './cardano/CardanoSignTransaction';

package/src/api/sui/SuiGetAddress.ts

@@ -0,0 +1,97 @@
+import { SuiGetAddress as HardwareSuiGetAddress } from '@onekeyfe/hd-transport';
+
+import { sha3_256 } from '@noble/hashes/sha3';
+import { bytesToHex } from '@noble/hashes/utils';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SuiAddress, SuiGetAddressParams } from '../../types';
+import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
+import { hexToBytes } from '../helpers/hexUtils';
+
+export default class SuiGetAddress extends BaseMethod<HardwareSuiGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    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: SuiGetAddressParams) => {
+      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,
+      });
+    });
+  }
+
+  publicKeyToAddress(publicKey: string) {
+    const hash = sha3_256.create();
+    // Ed25519
+    hash.update('\x00');
+    // hash.update('\x01'); Secp256k1
+    hash.update(hexToBytes(publicKey));
+    return `0x${bytesToHex(hash.digest().slice(0, 20))}`;
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.9.0',
+      },
+      model_touch: {
+        min: '3.5.0',
+      },
+    };
+  }
+
+  async run() {
+    if (this.hasBundle && supportBatchPublicKey(this.device?.features)) {
+      const res = await this.device.commands.typedCall('BatchGetPublickeys', 'EcdsaPublicKeys', {
+        paths: this.params,
+        ecdsa_curve_name: 'ed25519',
+      });
+      const result = res.message.public_keys.map((publicKey: string, index: number) => ({
+        path: serializedPath((this.params as unknown as any[])[index].address_n),
+        publicKey,
+        address: this.publicKeyToAddress(publicKey),
+      }));
+      return Promise.resolve(result);
+    }
+
+    const responses: SuiAddress[] = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('SuiGetAddress', 'SuiAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        address: address?.toLowerCase(),
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}