@onekeyfe/hd-core 0.2.8 → 0.2.9

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

@@ -85,3 +85,7 @@ 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/core/index.ts

@@ -45,6 +45,7 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
   passphraseState: method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
+  deriveCardano: method?.name.startsWith('cardano'),
 });
 
 let _core: Core;

package/src/data/messages/messages.json

@@ -1892,74 +1892,113 @@
     },
     "CardanoSignTxInit": {
       "fields": {
-        "signing_mode": {
-          "rule": "required",
-          "type": "CardanoTxSigningMode",
-          "id": 1
-        },
-        "protocol_magic": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 2
-        },
-        "network_id": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 3
-        },
-        "inputs_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 4
-        },
-        "outputs_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 5
-        },
-        "fee": {
-          "rule": "required",
-          "type": "uint64",
-          "id": 6
-        },
-        "ttl": {
-          "type": "uint64",
-          "id": 7
-        },
-        "certificates_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 8
-        },
-        "withdrawals_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 9
-        },
-        "has_auxiliary_data": {
-          "rule": "required",
-          "type": "bool",
-          "id": 10
-        },
-        "validity_interval_start": {
-          "type": "uint64",
-          "id": 11
-        },
-        "witness_requests_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 12
-        },
-        "minting_asset_groups_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 13
-        },
-        "derivation_type": {
-          "rule": "required",
-          "type": "CardanoDerivationType",
-          "id": 14
-        }
+          "signing_mode": {
+              "rule": "required",
+              "type": "CardanoTxSigningMode",
+              "id": 1
+          },
+          "protocol_magic": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 2
+          },
+          "network_id": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 3
+          },
+          "inputs_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 4
+          },
+          "outputs_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 5
+          },
+          "fee": {
+              "rule": "required",
+              "type": "uint64",
+              "id": 6
+          },
+          "ttl": {
+              "type": "uint64",
+              "id": 7
+          },
+          "certificates_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 8
+          },
+          "withdrawals_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 9
+          },
+          "has_auxiliary_data": {
+              "rule": "required",
+              "type": "bool",
+              "id": 10
+          },
+          "validity_interval_start": {
+              "type": "uint64",
+              "id": 11
+          },
+          "witness_requests_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 12
+          },
+          "minting_asset_groups_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 13
+          },
+          "derivation_type": {
+              "rule": "required",
+              "type": "CardanoDerivationType",
+              "id": 14
+          },
+          "include_network_id": {
+              "type": "bool",
+              "id": 15,
+              "options": {
+                  "default": false
+              }
+          },
+          "script_data_hash": {
+              "type": "bytes",
+              "id": 16
+          },
+          "collateral_inputs_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 17
+          },
+          "required_signers_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 18
+          },
+          "has_collateral_return": {
+              "type": "bool",
+              "id": 19,
+              "options": {
+                  "default": false
+              }
+          },
+          "total_collateral": {
+              "type": "uint64",
+              "id": 20
+          },
+          "reference_inputs_count": {
+              "type": "uint32",
+              "id": 21,
+              "options": {
+                  "default": 0
+              }
+          }
       }
     },
     "CardanoTxInput": {

package/src/device/Device.ts

@@ -32,6 +32,7 @@ export type InitOptions = {
   initSession?: boolean;
   deviceId?: string;
   passphraseState?: string;
+  deriveCardano?: boolean;
 };
 
 export type RunOptions = {
@@ -343,6 +344,10 @@ export class Device extends EventEmitter {
       payload.session_id = internalState;
     }
 
+    if (options?.deriveCardano) {
+      payload.derive_cardano = true;
+    }
+
     Log.debug('initialize payload:', payload);
 
     const { message } = await this.commands.typedCall('Initialize', 'Features', payload);

package/src/inject.ts

@@ -205,6 +205,13 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'suiGetPublicKey' }),
     suiSignTransaction: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'suiSignTransaction' }),
+
+    cardanoGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cardanoGetAddress' }),
+    cardanoGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cardanoGetPublicKey' }),
+    cardanoSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cardanoSignTransaction' }),
   };
   return api;
 };